{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network implementation (DQN) - with Prioritized Replay (PyTorch).\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**.\n",
    "$$ \\DeclareMathOperator*{\\max}{max}$$\n",
    "### Recap\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use ε-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update. \n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the q(s,a) for all the actions in the state `s`. It is denoted as $ \\hat{q}(s_t,a; w_{t}) $, where $w_{t}$ is the weights of the neural network which we are trying to learn as part of DQN learning. \n",
    "\n",
    "We use two networks, one target network to get the max q-value of next state denoted by $ \\max_a \\hat {q}(s_{t+1},a; w^{-}_{t}) $ and the primary network (online network) with weights $w_{t}$ which we are updated based on back propagation of the TD error through the network.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a,w^{-}_{t}) – \\hat{q}(S_t,A_t,w_t)] \\nabla \\hat{q}(S_t,A_t,w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values. \n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions (current state, action, reward, next state) in a buffer. Where each sample is denoted as a tuple: \n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s^{'}_{i}, done_{i})$$\n",
    "\n",
    "Subscript (i) denotes ith sample. We take N samples from experience replay selecting randomly and update the weights. Subscript (t) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gym\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Atari games and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAS+ElEQVR4nO3db4xd9Z3f8ffHxhiyIAHLQL3+E7upN7sm6ppo5I3EtqUJXXtpVCcPqBypkR8gOQ8cKairtLArNYlUS9tqk1SRmkikIKw0G8dSwmKltF1wE2UjURzDGmJjHLzBxRM7tnGWGlLi2DPfPpjjcDEznuv5w/Cbeb+kq3vu9/zOPd8fYj4+/vncuakqJEntWDDbDUiSLo/BLUmNMbglqTEGtyQ1xuCWpMYY3JLUmBkL7iQbkhxKcjjJvTN1HkmabzIT93EnWQj8GPhnwBDwQ+BjVfXctJ9MkuaZmbriXgccrqqfVNWvgB3Axhk6lyTNK1fM0PsuBY72vB4Cfn+8wTfeeGOtXLlyhlqRpPYcOXKEl19+OWPtm6ngHutkb1qTSbIF2AKwYsUK9u7dO0OtSFJ7BgcHx903U0slQ8DyntfLgGO9A6rq/qoarKrBgYGBGWpDkuaemQruHwKrk6xKciWwCdg1Q+eSpHllRpZKqup8kk8C/xNYCDxYVQdm4lySNN/M1Bo3VfUo8OhMvb8kzVd+clKSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmOm9NVlSY4ArwLDwPmqGkxyA/BNYCVwBPiXVfV3U2tTknTBdFxx/9OqWltVg93re4HdVbUa2N29liRNk5lYKtkIbO+2twMfmYFzSNK8NdXgLuCvkjyVZEtXu7mqjgN0zzdN8RySpB5TWuMGbquqY0luAh5L8ny/B3ZBvwVgxYoVU2xDkuaPKV1xV9Wx7vkk8DCwDjiRZAlA93xynGPvr6rBqhocGBiYShuSNK9MOriT/EaSay9sA38I7Ad2AZu7YZuBR6bapCTpDVNZKrkZeDjJhff5i6r6H0l+COxMcjfwEnDX1NuUJF0w6eCuqp8AvzdG/TTwoak0JUkan5+clKTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhozYXAneTDJyST7e2o3JHksyQvd8/U9++5LcjjJoSTrZ6pxSZqv+rnifgjYcFHtXmB3Va0GdnevSbIG2ATc0h3z5SQLp61bSdLEwV1V3wd+flF5I7C9294OfKSnvqOqzlbVi8BhYN30tCpJgsmvcd9cVccBuuebuvpS4GjPuKGu9hZJtiTZm2TvqVOnJtmGJM0/0/2PkxmjVmMNrKr7q2qwqgYHBgamuQ1JmrsmG9wnkiwB6J5PdvUhYHnPuGXAscm3J0m62GSDexewudveDDzSU9+UZHGSVcBqYM/UWpQk9bpiogFJvgHcDtyYZAj4DPBnwM4kdwMvAXcBVNWBJDuB54DzwNaqGp6h3iVpXpowuKvqY+Ps+tA447cB26bSlCRpfH5yUpIaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYyYM7iQPJjmZZH9P7bNJfppkX/e4s2fffUkOJzmUZP1MNS5J81U/V9wPARvGqH+xqtZ2j0cBkqwBNgG3dMd8OcnC6WpWktRHcFfV94Gf9/l+G4EdVXW2ql4EDgPrptCfJOkiU1nj/mSSZ7ullOu72lLgaM+Yoa72Fkm2JNmbZO+pU6em0IYkzS+TDe6vAO8B1gLHgc939YwxtsZ6g6q6v6oGq2pwYGBgkm1I0vwzqeCuqhNVNVxVI8BXeWM5ZAhY3jN0GXBsai1KknpNKriTLOl5+VHgwh0nu4BNSRYnWQWsBvZMrUVJUq8rJhqQ5BvA7cCNSYaAzwC3J1nL6DLIEeATAFV1IMlO4DngPLC1qoZnpHNJmqcmDO6q+tgY5QcuMX4bsG0qTUmSxucnJyWpMQa3JDXG4JakxhjcktQYg1uSGjPhXSXSfHTu9Vd5/ec/ZeGixbxrYCXJWB8KlmaHwS11TvxoN2eOjn6W7Nzrr/L66aNcdd3fY81dn2Hs3+YgzQ6DW+r88u+OcWboudluQ5qQa9yS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGjNhcCdZnuS7SQ4mOZDkU139hiSPJXmhe76+55j7khxOcijJ+pmcgCTNN/1ccZ8H/riqfhf4ALA1yRrgXmB3Va0Gdnev6fZtAm4BNgBfTrJwJpqXptN1q95PFrz51/f86hev8OqxH89SR9LYJgzuqjpeVU93268CB4GlwEZgezdsO/CRbnsjsKOqzlbVi8BhYN009y1Nu3f95jKy4M0/EiPnfsnZM6dmqSNpbJe1xp1kJXAr8CRwc1Udh9FwB27qhi0FjvYcNtTVLn6vLUn2Jtl76pQ/GJLUr76DO8k1wLeAe6rqzKWGjlGrtxSq7q+qwaoaHBgY6LcNSZr3+gruJIsYDe2vV9W3u/KJJEu6/UuAk119CFjec/gy4Nj0tCtJ6ueukgAPAAer6gs9u3YBm7vtzcAjPfVNSRYnWQWsBvZMX8uSNL/18w04twEfB36UZF9X+xPgz4CdSe4GXgLuAqiqA0l2As8xekfK1qoanu7GJWm+mjC4q+oHjP+Fex8a55htwLYp9CVJGoefnJSkxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEu/FrJw0VuqZ47uZ2T4/Cz0I43N4JY6V1x9LQO/+4/eUn/txE+oEX/Bpd45DG6pk4Qs7Oc3HUuzy+CWpMYY3JLUGINbkhpjcEtSY/r5suDlSb6b5GCSA0k+1dU/m+SnSfZ1jzt7jrkvyeEkh5Ksn8kJSNJ8088/oZ8H/riqnk5yLfBUkse6fV+sqj/vHZxkDbAJuAX4LeDxJL/tFwZL0vSY8Iq7qo5X1dPd9qvAQWDpJQ7ZCOyoqrNV9SJwGFg3Hc1Kki5zjTvJSuBW4Mmu9MkkzyZ5MMn1XW0pcLTnsCEuHfSSpMvQd3AnuQb4FnBPVZ0BvgK8B1gLHAc+f2HoGIfXGO+3JcneJHtPnTp1uX1L0rzVV3AnWcRoaH+9qr4NUFUnqmq4qkaAr/LGcsgQsLzn8GXAsYvfs6rur6rBqhocGBiYyhwkaV7p566SAA8AB6vqCz31JT3DPgrs77Z3AZuSLE6yClgN7Jm+liVpfuvnrpLbgI8DP0qyr6v9CfCxJGsZXQY5AnwCoKoOJNkJPMfoHSlbvaNEkqbPhMFdVT9g7HXrRy9xzDZg2xT6kiSNw09OSlJjDG5JaozBLUmNMbilHsnCsXfUyNvbiHQJBrfU48bf+QOuuOqaN9XO//JVXn7+B7PUkfRWBrfUY8GixZCLfiyqGD53dnYaksZgcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1Jh+fq2r1LSRkRHuuecejh49OuHYRQvD1n9yA9csfvMnKHfs2MFf//sH+jrf1q1bueOOOybVq9QPg1tzXlXx+OOPc/DgwQnHXnXlFdz9+5u4ctH1VI3+hfSKBb/i4MGD/OV/e7qv8334wx+eUr/SRAxu6SL/99wA+05t5FwtBmDJVS8yXHtnuSvpDa5xSz2KBbz0/36HX45cw3AtYrgWMfT6av7PL9bMdmvSrxncUo+RWsCJsysvqobztWg22pHG1M+XBV+VZE+SZ5IcSPK5rn5DkseSvNA9X99zzH1JDic5lGT9TE5Amk4LMszyq59/Uy0Mc9XCX8xSR9Jb9XPFfRb4YFX9HrAW2JDkA8C9wO6qWg3s7l6TZA2wCbgF2AB8OeP+kmPpnSUUK971PDcsOs4VIy/z8stHWPTad7l25NnZbk36tX6+LLiA17qXi7pHARuB27v6duB7wL/t6juq6izwYpLDwDrgifHOce7cOX72s59NbgbSBEZGRhgeHu5r7Lnzw3z1Lx9n8ZXf4/SZ1/nrZ18CCqr6Pt+ZM2f8/1lTdu7cuXH39XVXSXfF/BTwD4D/XFVPJrm5qo4DVNXxJDd1w5cC/7vn8KGuNq7Tp0/zta99rZ9WpMtWVbzyyit9jR0eKR598oUpne+JJ57g/PnzU3oP6fTp0+Pu6yu4q2oYWJvkOuDhJO+7xPCM9RZvGZRsAbYArFixgk9/+tP9tCJdtuHhYR566CFOnjz5tpxv/fr13H333W/LuTR3ffOb3xx332XdVVJVrzC6JLIBOJFkCUD3fOGnYghY3nPYMuDYGO91f1UNVtXgwMDA5bQhSfNaP3eVDHRX2iS5GrgDeB7YBWzuhm0GHum2dwGbkixOsgpYDeyZ5r4lad7qZ6lkCbC9W+deAOysqu8keQLYmeRu4CXgLoCqOpBkJ/AccB7Y2i21SJKmQT93lTwL3DpG/TTwoXGO2QZsm3J3kqS38JOTktQYg1uSGuNvB9Scl4Q77riD9773vW/L+d797ne/LefR/GVwa85bsGABX/rSl2a7DWnauFQiSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhrTz5cFX5VkT5JnkhxI8rmu/tkkP02yr3vc2XPMfUkOJzmUZP1MTkCS5pt+fh/3WeCDVfVakkXAD5L8927fF6vqz3sHJ1kDbAJuAX4LeDzJb/uFwZI0PSa84q5Rr3UvF3WPusQhG4EdVXW2ql4EDgPrptypJAnoc407ycIk+4CTwGNV9WS365NJnk3yYJLru9pS4GjP4UNdTZI0DfoK7qoarqq1wDJgXZL3AV8B3gOsBY4Dn++GZ6y3uLiQZEuSvUn2njp1ahKtS9L8dFl3lVTVK8D3gA1VdaIL9BHgq7yxHDIELO85bBlwbIz3ur+qBqtqcGBgYDK9S9K81M9dJQNJruu2rwbuAJ5PsqRn2EeB/d32LmBTksVJVgGrgT3T2rUkzWP93FWyBNieZCGjQb+zqr6T5GtJ1jK6DHIE+ARAVR1IshN4DjgPbPWOEkmaPhMGd1U9C9w6Rv3jlzhmG7Btaq1JksbiJyclqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjUlWz3QNJTgG/AF6e7V5mwI04r9bM1bk5r7a8u6oGxtrxjghugCR7q2pwtvuYbs6rPXN1bs5r7nCpRJIaY3BLUmPeScF9/2w3MEOcV3vm6tyc1xzxjlnjliT15510xS1J6sOsB3eSDUkOJTmc5N7Z7udyJXkwyckk+3tqNyR5LMkL3fP1Pfvu6+Z6KMn62el6YkmWJ/lukoNJDiT5VFdvem5JrkqyJ8kz3bw+19WbntcFSRYm+Zsk3+lez5V5HUnyoyT7kuztanNibpNSVbP2ABYCfwv8feBK4BlgzWz2NIk5/GPg/cD+ntp/BO7ttu8F/kO3vaab42JgVTf3hbM9h3HmtQR4f7d9LfDjrv+m5wYEuKbbXgQ8CXyg9Xn1zO9fA38BfGeu/L/Y9XsEuPGi2pyY22Qes33FvQ44XFU/qapfATuAjbPc02Wpqu8DP7+ovBHY3m1vBz7SU99RVWer6kXgMKP/Dd5xqup4VT3dbb8KHASW0vjcatRr3ctF3aNofF4ASZYB/xz4Lz3l5ud1CXN5bpc028G9FDja83qoq7Xu5qo6DqMBCNzU1Zucb5KVwK2MXp02P7duOWEfcBJ4rKrmxLyA/wT8G2CkpzYX5gWjf7j+VZKnkmzpanNlbpftilk+f8aozeXbXJqbb5JrgG8B91TVmWSsKYwOHaP2jpxbVQ0Da5NcBzyc5H2XGN7EvJJ8GDhZVU8lub2fQ8aovePm1eO2qjqW5CbgsSTPX2Jsa3O7bLN9xT0ELO95vQw4Nku9TKcTSZYAdM8nu3pT802yiNHQ/npVfbsrz4m5AVTVK8D3gA20P6/bgH+R5AijS44fTPJfaX9eAFTVse75JPAwo0sfc2JukzHbwf1DYHWSVUmuBDYBu2a5p+mwC9jcbW8GHumpb0qyOMkqYDWwZxb6m1BGL60fAA5W1Rd6djU9tyQD3ZU2Sa4G7gCep/F5VdV9VbWsqlYy+nP0v6rqX9H4vACS/EaSay9sA38I7GcOzG3SZvtfR4E7Gb1j4W+BP53tfibR/zeA48A5Rv+kvxv4TWA38EL3fEPP+D/t5noI+KPZ7v8S8/oDRv96+Sywr3vc2frcgH8I/E03r/3Av+vqTc/rojnezht3lTQ/L0bvOnumexy4kBNzYW6TffjJSUlqzGwvlUiSLpPBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSY/4/Ofqs2rMMjXoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden layers with Relu activation and final layer being logits with dimension equal to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 192))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(192, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, 64))\n",
    "        self.network.add_module('relu3', nn.ReLU())\n",
    "        self.network.add_module('layer4', nn.Linear(64, n_actions))\n",
    "        # \n",
    "        self.parameters = self.network.parameters\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prioritized Experience replay\n",
    "\n",
    "In this notebook, we will use `Prioritized` version replay buffer as explained in the paper https://arxiv.org/pdf/1511.05952.pdf. \n",
    "\n",
    "Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "We will be using prioritized version of experience replay. \n",
    "\n",
    "The interface to PrioritizedReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `update_priorities(idxs, new_priorities)` - returns nothing. \n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "In usual replay buffer, we select training batch with equal probability of selection for each sample/transition stored in the buffer. However, in Prioritized replay, we assign an importance score $p_i$ to each sample/transition. One approach to importance score is to use the absolute value of TD error $\\delta_i$ with addition of small constant $\\epsilon$ to avoid the edge case of error being zero and not picked up again ever.  \n",
    "\n",
    "$$ p_i = |\\delta_i| +\\epsilon$$\n",
    "\n",
    "$$\\delta_i = r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "At the time of picking the batch samples from buffer, the individual importance scores for samples are converted to probability which defines the probability of a sample being picked:\n",
    "\n",
    "$$P(i) = \\frac{p_i^{\\alpha}}{\\sum_i p_i^{\\alpha}}; \\alpha=0.6 $$\n",
    "\n",
    "$\\alpha$ is a hyper parameter and in the paper cited above, a value of 0.6 was found to work the best. We are using the same value in our code below:\n",
    "\n",
    "\n",
    "TD error for the samples chosen in the batch is used to calculate the loss and $\\nabla_w(L)$. The TD error is also used to update the importance score $p_i$ of the samples back in the buffer. \n",
    "\n",
    "\n",
    "The probability $P(i)$ is also used to calculate a weight, an importance sampling value, to adjust for the fact that samples now have a non uniform probability of being picked. The weight vector for batch samples as given below:\n",
    "\n",
    "$$w_i = \\left(\\frac{1}{N}.\\frac{1}{P(i)} \\right)^\\beta; \\beta=0.4$$\n",
    "\n",
    "Value of $\\beta=0.4$ has been taken from the paper cited above. \n",
    "\n",
    "While calculating the training loss, the individual TD errors $\\delta_i$ are weighed by the weights $w_i$. The updated batch loss equation is shown a few cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrioritizedReplayBuffer:\n",
    "    def __init__(self, size, alpha=0.6, beta=0.4):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.priorities = np.ones(size)\n",
    "        self.epsilon = 1e-5\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        max_priority = self.priorities.max()\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.priorities[self.next_id] = max_priority\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        priorities = self.priorities[:len(self.buffer)]\n",
    "        probabilities = priorities ** self.alpha\n",
    "        probabilities /= probabilities.sum()\n",
    "        N = len(self.buffer)\n",
    "        weights = (N * probabilities) ** (-self.beta)\n",
    "        weights /= weights.max()\n",
    "\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size, p=probabilities)\n",
    "\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        weights = weights[idxs]\n",
    "        \n",
    "        \n",
    "        return  (np.array(states), np.array(actions), np.array(rewards), \n",
    "                np.array(next_states), np.array(done_flags), np.array(weights), np.array(idxs))\n",
    "        \n",
    "    def update_priorities(self, idxs, new_priorities):\n",
    "        self.priorities[idxs] = new_priorities+self.epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, done, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Q-learning\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_w L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t})$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max} w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_td_loss_priority_replay(agent, target_network, replay_buffer,\n",
    "                                    states, actions, rewards, next_states, done_flags, weights, buffer_idxs,\n",
    "                                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "    weights = torch.tensor(weights, device=device, dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "    \n",
    "    #compute each sample TD error\n",
    "    loss = ((predicted_qvalues_for_actions - target_qvalues_for_actions.detach()) ** 2) * weights\n",
    "    \n",
    "    # mean squared error loss to minimize\n",
    "    loss = loss.mean()\n",
    "    \n",
    "    # calculate new priorities and update buffer\n",
    "    with torch.no_grad():\n",
    "        new_priorities = predicted_qvalues_for_actions.detach() - target_qvalues_for_actions.detach()\n",
    "        new_priorities = np.absolute(new_priorities.detach().numpy())\n",
    "        replay_buffer.update_priorities(buffer_idxs, new_priorities)\n",
    "        \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x1e10bf1f190>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set a seed\n",
    "seed = 13\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state = env.reset()\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "# let us fill experience replay with some samples using full random policy\n",
    "exp_replay = PrioritizedReplayBuffer(10**4)\n",
    "for i in range(100):\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "    if len(exp_replay) == 10**4:\n",
    "        break\n",
    "print(len(exp_replay))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 45000\n",
    "\n",
    "#init Optimizer\n",
    "opt = torch.optim.Adam(agent.parameters(), lr=1e-4)\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 20\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6sAAAE/CAYAAACgilX5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABulklEQVR4nO3dd3xc1Zn/8c8z6t22bMsVd1NsuqkGIkIIJJBANoGQACFtSXbJJtklv03b9LLsZjdtk2yWkoQkhARSCAFCDaIaG5tq4265y1Wyyow0o5k5vz/uHVmW1TXStO/79fJLM3fu3Pvo2J65zz3nPMecc4iIiIiIiIikk0CqAxARERERERHpScmqiIiIiIiIpB0lqyIiIiIiIpJ2lKyKiIiIiIhI2lGyKiIiIiIiImlHyaqIiIiIiIikHSWrIlnAzOrM7KOpjmOozOynZvalJB/zg2b2bDKPKSIigzOWn8FmNtvMnJnl9/H6F8zs9rGIZajM7GNm9v1Ux9GfdLm2MLOvmtmv/cc1ZrbWzIpSHZeMDSWrkrbMbKuZRcxsYo/tr/hfTrNTFJokiXPu4865b6Q6DhGRXGRmbd3+xM2svdvza/0kodPMWv0/G8zsR2Y2NdWxD4Zz7tvOuQGTrbFOysysEPg34Dtjdc6BdE8I05lzbi/wJHBjqmORsaFkVdJdPfC+xBMzOxEoSV04h/V1J3eUz2lmlrL/t6n4nUVEZHQ458oTf4DtwDu6bbvL3+13zrkKYALwLmAKsCpTEtbRNszv5SuAdc65XaMRUw64C/hYqoOQsaFkVdLdr4APdHt+A/DL7juYWZGZ/ZeZbTezvf7Q0hL/tfFm9oCZ7TezJv/xjG7vrTOzb5jZc/5d40d79uR227fWzHaa2WfNbA/wczMLmNnnzGyzmR00s3vMbIK//51mdrP/eLrfG/yP/vP5Ztbof8kNJsZvmdlzQAiYa2YXm9k6M2s2sx8B1lcD+ndLf29mv/N/x5fM7ORur08zsz/45683s0/28t5fm1kL8MFejt9f+yfa7AtmdsDvLb+223t/YWbf9B9P9H/3Q37bPJO4ADCz4/12OGRma8zsnd2OUW1m95tZi5mtAOb1iO84M3vMP+Z6M7u6r7YSEZHeOec6nXNrgPcC+4GbB/M+MzvXzF70v69eNLNzu732QTPb4n831Se+H/zvyKf89xwws98NcJpr/e+gA2b2xW7H7z58tNj/Ljvof5e8aN6Q0m8B5wM/Mq9H+UeDiLvn9/LNZraqx+99s5nd10e8bwOe6rZvr7F1O9c3zex5P76/+N97d/nfey9at5FmA8Q9zf++bDSzTWb29/72S4EvAO/1z/Fqt1hnWR/XSGZ2th/XITN71cxqe7RRn9dXA7x3jv/332pmjwE9r8uW410LzeqjfSWLKFmVdPcCUOknK3l4X5I9h6n8B7AQOAWYD0wHvuy/FgB+DswCjgHagR/1eP/7gQ8Bk4FC4DP9xDMF7+7yLLwhKJ8ErgTeBEwDmoAf+/s+BdT6j98EbPF/AlwAPOOcc4OM8Xr/fBVAM/AHvCFEE4HNwNJ+YgbvLu69fuy/Ae4zswI/GfwL8Cpeu10EfNrMLunx3t8D4/DuZvbUX/uD12YT/e03ALea2bG9HOdmYCcwCajB++J0Zlbgx/go3t/RPwF3dTvGj4EOYCrwYf8PAGZWBjzm/86T8Xrpf2Jmi/psKRER6ZNzLgb8GS/B65d5N28fBH4IVAPfBR70k60yf/vb/J7bc4FX/Ld+A+8zfzwwA/ifAU51HnAs3nfYl83s+F72uQGoAmb6sXwcaHfOfRF4BviE36P8if7i7na87t/LPwTm9DjvdXg33HtzIrB+oNi6vX6Nf77peDdkl+FdN0wA1gJfgf7b2z/O3Xjfs9OA9wDfNrOLnHMPA9/G60Uvd8513dCmj2skM5vun+ubfhyfAf5gZpOS8N7fAKvwrh2+4bdPF+dcFNgEdI9TspSSVckEid7Vi4F1QNewGTMz4O+Bf3bONTrnWvE+cK8BcM4ddM79wTkX8l/7FocTxoSfO+c2OOfagXvwkq6+xIGvOOfC/v4fA77onNvpnAsDXwXeY95w2aeA8/2E8ALgPzmcVL7Jf32wMf7CObfG/4B+G/CGc+73zrlO4PvAngHacFW3/b8LFANnA2cAk5xzX3fORZxzW4DbEu3nW+acu885F/d/5y4DtX83X/Lb7Cm8L6jeejc78RLOWf4d/EQyfzZQDtzix/g34AHgff4NjHcDX3bOBZ1zq4E7ux3zcmCrc+7nzrmoc+4lvET/PQO0l4iI9G03XpIxkMuAjc65X/mfwXfjfY+/w389Diw2sxLnXIPfcwve98EsYJpzrsM5N1DBpq8559qdc6/i3XztLYnpxEvg5jvnYs65Vc65lmHGDd2+l/3v/9/hJaj4N0Rn431X9WYc0DqE2H7unNvsnGsG/gpsds497l8T3AucOlDcZjYTL6n/rN+mrwC34yXB/enrGuk64CHn3EP+9cFjwErg7SN5r5kdg3dtkrhueBrvhnVPrX47SpZTsiqZ4Fd4d+c+SI8hwHi9cKV482cOmdkh4GF/O2ZWamb/Z2bbzBvG+jQwzk9yEroneiG8xKgv+51zHd2ezwL+1O3ca4EYUOOc2wy04X04n4/3pbXb7xHsSlYHGeOObo+ndX/uJ3TdX+9N9/3jHL6zOguYlojf/x2+gNez2du5e+q3/X1Nzrlgt+fb/HP39B28O6WPmjcs7HP+9mnADj/u7seY7p8nv0eM27o9ngWc1eP3uxavt1dERIZnOtA4iP2mceRnMv7z6f73wnvxehEbzOxBMzvO3+df8aa3rDBv6seH6d9gvsd/BTwC/NbMdpvZf/ojd4YUd7fnPb8b7wTe79/EvR64x09ie9OE1yM72Nj2dnvc3svzxO/bX9zTgMRN5b5+p9701bazgKt6fL+eh3fTeSTvnUbv1w09VQCHBohdsoCSVUl7zrlteIWW3g78scfLB/A+qBc558b5f6qcVywCvKGlxwJnOecq8Xo4oZ85ngOF0+P5DrwhTOO6/Sl2h4smPIXXi1fob3sKr5d4PIeHOw0mxu7nbcAbKuTt5H0xzqR/3fcP4A2r2u3HX98j/grnXPc7oz1/5+4Gan+A8f5wr4Rj/HMfwTnX6py72Tk3F+/u9b+Y2UX+vjPtyAIWx+D1sO8Hoj1+/2O6Pd4BPNXj9yt3zv1DP7+TiIj0wf8sfgfe0NmB7MZLTLpLfH7jnHvEOXcxXpKyDm9kD865Pc65v3fOTcMbwfQTM5s/krj9ETtfc86dgDfk+HIO18To+T3Xb9y9vcc59wIQwbs5/X76HgIM8Bre9JnBxDYU/cW9G5hgZhW9vAb9f9f3Zgfwqx7fr2XOuVtG+N4Ger9u6OKPXpuP14suWU7JqmSKjwBv7nGnLdFLeBvwPTObDF3FjBJzLivwkqlD/lyOryQ5rp8C30pM8jezSWZ2RbfXnwI+gddbClCHN+fyWefN+xlOjA8Ci8zs7/wP7E8ycE/h6d32/zQQxpsPvAJoMa9oVImZ5ZnZYjM7Y8DfnEG1f8LXzKzQzM7H+xK+t+exzOxy84pqGNCC10MdwyukEAT+1Z9nW4t3ofRbvw3/CHzV76E+gSPntjwALDSz6/33FpjZGX3MZxIRkT74n5/H4817nII3pWQgD+F9Br/fzPLN7L3ACcAD5hU3eqeflITxRiLF/HNdZYcLDTbhJVKxXo4/lPgvNLMT/VFLLXhDbxPH3AvMHUzcA5zml3g1J6IDDF1+iG7TfQaIbSj6jNs5twN4Hvh38wo6nYR3bZWoRbEXmG2Dr2z8a7zhxZf41w7F5hVVnDHgO/t5r99BsZLD1w3nceTwa4Az8ab49NbjKllGyapkBH+uxso+Xv4s3vDRF/xhtI/j9VSCN5+zBK8H8AW8IarJ9APgfryhq63+Oc7q9vpTeMloIll9Fm/Y7NPd9hlSjM65A8BVwC3AQWAB8NwAcf4Zb7hVE97wpL/z7+TG8L4ETsHrvT6AN4elaoDjdddf+4M3DKgJ767uXcDHnXPrejnOAv+9bXjFI37inKtzzkWAd+LN1T0A/AT4QLdjfAJvaNEe4Bd4RScAr7cWeCveHNrd/j7/AWgxcRGRwXmvmbXhDbm8H+9753Tn3FEjZHpyzh3Eu0F5s/++fwUu97/HAv723XhDit8E/KP/1jOA5f557wc+5ZyrH+HvMQWvWGAL3pSdpzhcsPEHePUmmszshwPE3Z9fAYvpv1cVvDmYx5lZYkpMf7EN2iDifh/eXNrdwJ/wanA85r+WuIl80MxeGsS5duAVYPwC3iinHcD/YxC5xSDe+368a6lGvBv4PaeAXYvXWSA5wLzpbiKSrczsq3hFG65LwblrgV875wZzp1VERCRjmbds2z7gNOfcxgH2vRE4wTn36bGILVv4o7ieAk7tUUNEslR+qgMQEREREckC/wC8OFCiCuCcu3UM4sk6zrl9gKby5BAlqyIiIiIiI2BmW/EKI16Z2khEsouGAYuIiIiIiEjaUYElERERERERSTtKVkVERERERCTtpP2c1YkTJ7rZs2eP+DjBYJCysrKBd5R+qR2TQ+2YHGrH5Mi1dly1atUB59ykVMeRyfTdnN7UrqND7Zp8atPRkYnt2td3c9onq7Nnz2blyr6W1xy8uro6amtrRx5QjlM7JofaMTnUjsmRa+1oZlpIfoT03Zze1K6jQ+2afGrT0ZGJ7drXd7OGAYuIiIiIiEjaUbIqIiIiIiIiaUfJqoiIiIiIiKQdJasiIiIiIiKSdpSsioiIiIiISNpRsioiIiIiIiJpR8mqiIiIiIiIpJ0Bk1Uz+5mZ7TOz1d22TTCzx8xso/9zfLfXPm9mm8xsvZld0m376Wb2uv/aD83Mkv/riIiIiIiISDYYTM/qL4BLe2z7HPCEc24B8IT/HDM7AbgGWOS/5ydmlue/53+BG4EF/p+exxQREREREREBIH+gHZxzT5vZ7B6brwBq/cd3AnXAZ/3tv3XOhYF6M9sEnGlmW4FK59wyADP7JXAl8NcR/wYikpXW72mlsiSfqVUlo3L8aCzOg683EIrERuX4mWT9jk4aVmxPdRj9GldSwNtOnJrqMEQyVkdnjL+t28dFx0+mKD9v4DeIiKSBAZPVPtQ45xoAnHMNZjbZ3z4deKHbfjv9bZ3+457be2VmN+L1wlJTU0NdXd0wwzysra0tKcfJdWrH5FA7DuwLz4SYXZXHjScV9bnPSNpxfWOMf1/RMczostCa11MdQb9mlBslB9enOgyRjPX7VTv5t/tWM6WymBe+cFGqwxERGZThJqt96W0equtne6+cc7cCtwIsWbLE1dbWjjiwuro6knGcXKd2TA6148Aizz5GfnkVtbVn9rnPSNoxsmYPrFjFnR8+k2NrKoYZZXZYtux5zjnn3FSH0a+8gDGpou8bFyLSv9aOKAB7WjqIxuLk56nGpoikv+Emq3vNbKrfqzoV2Odv3wnM7LbfDGC3v31GL9tFRHoVisRoae8c1eMDzBxfwpSq4lE7TyYYXxzI+TYQyTa3Pr2ZpfMnsmlfG7sPdVCQd7jfYP4X/8rWWy5LYXQiIoMz3GT1fuAG4Bb/55+7bf+NmX0XmIZXSGmFcy5mZq1mdjawHPgA8D8jilxEslY87ghFYrR2jH6yWlaU7AEmIiKptaM1zrefW0dxQYCOzjgAtcdOOmIf5xxamEFE0t2AV2lmdjdeMaWJZrYT+ApeknqPmX0E2A5cBeCcW2Nm9wBvAFHgJudconrJP+BVFi7BK6yk4koi0qv2Tu9jo8UftjYaQhHv2CWFKjQiItlh5dZG2sJRvvRcO0BXogpQt37/EfsGIzHKdbNORNLcYKoBv6+Pl3qdne+c+xbwrV62rwQWDyk6EclJQT+RHM1hwMGwlxCXFihZFZHs8IGfrTiiwvlJM6p4bWdzr/t2dMb4w6qdLKyp4Jx51WMVoojIkOiWmoiknZCfSIajccLR2KgssxDqjFKUH1CRERHJGj2X4iro5/Otpb2Tr9y/BkDzV0UkbekqTUTSTqJnFQ5XsEy2UDhGqYYAi0gW298a7vO1t/3gmTGMRERkeJSsikja6d47MGrJaiRGaaEGl4hIdnDuyBUBLzx2EtsbQ0dsu+aMwws2hKOH57MGw6NXH0BEZCSUrIpI2ul+4TRa81ZDkah6VkUkayQK0l171jH87JJSnuxRUAng029ZyMTywqO2r9/bOurxiYgMh5JVEUk73XtWW0Zp+ZpQJEapKmGKSJbYfcirAHzqMeMJ9LIkzYLJ5UypKmblv13cte27V58MwJpdvRdhEhFJNSWrIpJ2xmYYcFSVgEUkaySKJSXWpz5uSsURr3/zysVHPP7YBXN516nTAdjpJ7oiIulG3QoiknZCkbEYBhxjalXBqBxbRGSsbfSH8v7dqTN4ecU27rtpKX94aSdXnT6TgjzDuvW2Xnf2rK7HNZVFNAUjYx6viMhgqGdVRNJOYg1UGN0CSyUqsCQiWaK6vIiAQVWpdxOuuCCPa8+aRWF+4IhEtadZE8rYtK9trMIUERkSJasiknZCkShmELDRnLMapUwFlkQkS8TijstOmjbk9504o4o1u1uIxuID7ywiMsaUrIpI2gmGY5QV5lNelD+q66yWKFkVkSzgnKO5vZPyYRSNO35qJeFo/KhlbkRE0oHGwIlI2kksK1OYHxiVOavOOYKRKGUaBiwiWWBPSweNwQgLa8qH/N6KYu9zsHthOxGRdKErNRFJO8FIjLKifIoL8kZlGHA4GifuoLRIPasikvl2H+oAYHZ12ZDfW+xXRQ9HlayKSPpRsioiaScU9npWy4vyuxa6T+rx/R4ELV0jItlgb4uXrNZUFg/5vUX53oywjk7NWRWR9KM5qyKSdhJDdCtLCkZlGHBiaZzSYczvEhFJN4eT1aIhv1c9qyKSzpSsikjaaY/EKC3Ko6J4dAosdfWsqsCSiGSBxGda2TBuwCWqore0j04xOxGRkVCyKiJpJxjxqgFXFheMypzVrgs7FViSHGJmxWa2wsxeNbM1ZvY1f/sEM3vMzDb6P8enOlYZmnCn95mWGNI7FDVV3tDhT//uFb7859VJjUtEZKSUrIpI2gmFo5QU5lFZnE9bOEo87pJ+fEBL10iuCQNvds6dDJwCXGpmZwOfA55wzi0AnvCfSwbpiMYpyg9gZkN+b0W33thfLtuWzLBEREZMyaqIpB2vZzWPypICnIO2SHKHp6lnVXKR87T5Twv8Pw64ArjT334ncOXYRycjEe6Mdc09HSoz4x0nT0tyRCIiyaErNRFJO6FIlNIibxgwQEt7Z9fjZAhG1LMqucnM8oBVwHzgx8655WZW45xrAHDONZjZ5D7eeyNwI0BNTQ11dXUjjqetrS0px8l19TvCWDzW1ZZDbdd3THb8xX+sv4++6d9r8qlNR0c2tauSVRFJK5FonM6Yo6wwr2ux+mQXWWrvKkaiZFVyi3MuBpxiZuOAP5nZ4iG891bgVoAlS5a42traEcdTV1dHMo6T6/6052Wq2g91teWw2vWxBwH099EP/XtNPrXp6MimdtUwYBFJK13LyvhL1wBJX74m2FUNWPfrJDc55w4BdcClwF4zmwrg/9yXushkODo6YxTnj+zm26JplQBJrxEgIjISSlZFJK0Eu/V6JnpWW5Lcs5oosKSlaySXmNkkv0cVMysB3gKsA+4HbvB3uwH4c0oClGELR+MUF4zsku6d/rzV/W3hZIQkIpIU6lYQkbRyOJE8PGe1NcnL14Q6YxTmBSjI0/06ySlTgTv9easB4B7n3ANmtgy4x8w+AmwHrkplkDJ0HZ0xikbYs3qC37O6bk8rNZXFyQhLRGTElKyKSFoJ9dazmuRhwImlcURyiXPuNeDUXrYfBC4a+4gkWYLhGBPKCkd0jFkTygDY19KRjJBERJJC3QoiklaC3easVnT1rCZ/6ZoyJasikgWcc2w9EOSYCaUjOs7kyiIA9rVqGLCIpA8lqyKSVkLhRPGjPArzA5QU5NGS7GHAkZh6VkUkK+xvC9MajjJvUtmIjpNYp/U7j6zn1y9sS0ZoIiIjpmRVRNJK955VgIri/FHoWY1SVqRZECKS+ZpD3s286vKipB0zkax+9M6VfO0va5J2XBGRoVKyKiJpJdRjDdTKkoKk96wGIzFKCtSzKiKZr80vSleehBtwiToBeQFj9a5mHl+7l58/t5Xdh9pHfGwRkeFQsioiaSUYPrpntaU9uT2r7ZGYelZFJCuEIoenTozUJL93Nj9gPLpmT9f2+gPBER9bRGQ4lKyKSFrpeeFVWVyQ9KVrghFVAxaR7PDqzkMAVJUWjPhYN7/1WABmVZd1fRYDbD2oZFVEUkPJqoiklWAkSmH+4TVQvWHASZ6zGlY1YBHJDv/58HoApo8rGfGxLjtpKhPLiygryicSizOutICKonw27Gkd8bFFRIZDyaqIpJWeiaRXYCnZ1YCjXcOMRUQylXOOvIAxsbywa6mvkSouCBDujBGJxinMC1BcmMedy7axaltTUo4vIjIUSlZFJK2EIrEjEsnK4gJa2qM455J8DvWsikhma++MEYs7PnLe3KQds6Mzxis7DnnJan6A/f66qz94YmPSziEiMljqWhCRtOItK3Nkz2okFiccjXetAzgSkWicaNypwJKIZLzdhzoAGJeE+aoJB9oiHGiLsOVAkML8QNfyYVMqk7c0jojIYKlnVUTSSjASo6R7z2qJdxGWrOVrQv46rlq6RkQy3epdzQBUlSQvWe0uEo3zf9edDpC0YcYiIkOhZFVE0kooHD1izmqlv+5fspav6bmOq4hIpuqMxQE4cXpV0o55301Lj3h+7vyJTKkspi3Jhe5ERAZD4+BEJK0EIzHGlRZ2Pa/07+Ynq8hSV8+qCiyJSIbr6PRuviVjikTCKTPH8fT/u5Dl9QdZUFMBeNMxfrdyB395bTevf/US8gKWtPOJiPRHV2siklZ6zlmtLPF7VpN0V7+rZ1UFlkQkw3V0ej2rxQXJHSh3THUpx1SXdj1vDEYA7/OzobmdGeNL+3qriEhSaRiwiKSVYPjIasAVSe5ZDYa9ZLVEyaqIZLj2UehZ7c1BP1kFeGFL46ieS0SkOyWrIpJWQpGec1b9AktJmrPa3ukdp0zDgEUkw3V0xsgPGAV5o3s5d/PFC7sef+beV0f1XCIi3Y3o083M/tnM1pjZajO728yKzWyCmT1mZhv9n+O77f95M9tkZuvN7JKRhy8i2SQed94aqEXde1YTw4CT27OqdVZFJNN1dCZnSa+BfOLN87seawqFiIylYSerZjYd+CSwxDm3GMgDrgE+BzzhnFsAPOE/x8xO8F9fBFwK/MTM9IknIl06okfPJy0tzCMvYEkvsFSqdVZFJMO1d8bGJFk1M+r//e1MqyrmlGPGjfr5REQSRjpuJB8oMbN8oBTYDVwB3Om/fidwpf/4CuC3zrmwc64e2AScOcLzi0gW6er17JZImhmVxfnJX7pGvQMikuHCnbGkF1fqi5lx0oxx7G0Jj8n5RERgBMmqc24X8F/AdqABaHbOPQrUOOca/H0agMn+W6YDO7odYqe/TUQEONzr2TORrCguSGLPqgosiUh2aO+MUTIGPasJNZVFbD0Q7FoyR0RktA17HJw/F/UKYA5wCLjXzK7r7y29bHN9HPtG4EaAmpoa6urqhhtml7a2tqQcJ9epHZND7di77S3eBdCWDeuoa9nUtd2iHdTv2ntUmw2nHddujJBn8PwzT2OmtQJB/x5FMlVrR5Ty4rGb0nDc1EqiccfOpnbmTy4fs/OKSO4aySfcW4B659x+ADP7I3AusNfMpjrnGsxsKrDP338nMLPb+2fgDRs+inPuVuBWgCVLlrja2toRhOmpq6sjGcfJdWrH5FA79m7l1kZ4fhlnnnYyFyyc1LV92oYX6IzFqa0994j9h9OOdS1rKN29kwsvvDAZIWcF/XsUyUytHZ1UlRaO2fkmlhcBh0fBiIiMtpFMdNgOnG1mpeZ1T1wErAXuB27w97kB+LP/+H7gGjMrMrM5wAJgxQjOLyJZJpiYT1p05LC2ypJ8WjuStHRNJKZla0Qk48Xjjq0HQ0wsH7tkNTFFIzGdQkRktA37is05t9zMfg+8BESBl/F6Q8uBe8zsI3gJ7VX+/mvM7B7gDX//m5xz+rQTkS6hsF+pt0cyWVFckLylayJRLVsjIhnvS39eTXN7JyfPGDdm50zM9W9XsioiY2RE3QvOua8AX+mxOYzXy9rb/t8CvjWSc4pI9urqWe2RrFYWFyS1Z7W0SMmqiGS2u5ZvB2DauJIxO2fiRmJQw4BFZIyMTb1zEZFBOLwG6tHDgNvCUaKx+IjPEYxEKS3QMGARyQ6Lp1eO2bkSo1I+8ZuXuemul8bsvCKSu5SsikjaCPXRs1pRXABAW3jkd/PVsyoi2aS6rGjMztV9CsWDrzfgnOPWpzezp7ljzGIQkdyiZFVE0kYoHMWMoxa5r/SXZkjGUOBgJKY5qyKSNQrzx+5SrqzoyBuJWw+G+PZD67jpN+plFZHRoWRVRNJG0K/U23P900TPanP7yIsshcLRowo4ieQCM5tpZk+a2VozW2Nmn/K3f9XMdpnZK/6ft6c6VunfgbYwANecMXOAPZOruODwjb6TZ44jFvemZhwKRcY0DhHJHUpWRSRthCLRrmqT3VWWJK9nNdQZ61p+QSTHRIGbnXPHA2cDN5nZCf5r33POneL/eSh1IcpgrGtoBY5MHsfK6199K9PHlRCNxYlEHQBuzKMQkVyhZFVE0kYw3HsiWen3rCZj+ZpQOEaJelYlBznnGpxzL/mPW/HWRp+e2qhkODr9YnNXnDJtzM9dUVzAKTPH0d4Zo8nvUd2yP8iNv1w55rGISPZTsioiaSMU6X2IbiJZHWnPamcsTiQWV8+q5Dwzmw2cCiz3N33CzF4zs5+Z2fjURSaD8fquZuDoOaRj5bVdh9iyP8i1ty/v2vboG3uJx9XHKiLJpe4FEUkbwXCMsl4q9SaGAbeMcM5qotpwb0ONRXKFmZUDfwA+7ZxrMbP/Bb6BN5rzG8B/Ax/u5X03AjcC1NTUUFdXN+JY2traknKcXOKc47uPhQBY/fKL7C4+ut9htNt1R2N7r9sf+VsdJfnW62vZQP9ek09tOjqyqV2VrIpI2ghFoowrLTxqe7nfezDSYcDtiaVxUtQbIZJqZlaAl6je5Zz7I4Bzbm+3128DHujtvc65W4FbAZYsWeJqa2tHHE9dXR3JOE4u2dEYgkeeBOBdl1x4VEE6GP12zX/0IaK99KKevORspo0rGbXzppr+vSaf2nR0ZFO7ahiwiKSNYKT3ntX8vABlhXkjHgYcjHjv19I1kovMy2ruANY6577bbfvUbru9C1g91rHJ4G1v9HpVf3vj2b0mqmMhP6/38z69Yf8YRyIi2U7JqoikjfZIrM9lZSqKC0Y8DDjRs6qlayRHLQWuB97cY5ma/zSz183sNeBC4J9TGqX0q9UfYZKYy58KHzlvTtfjc+dVc8rMcQB87o+vpygiEclWumITkbQRjET7LH5UWZI/8p7VsHpWJXc5554FeusS01I1GeSvq/cAUFGcuku4z7z1WC5YMIn33voCVy+ZiRl86revpCweEcle6lkVkbQRCsco7WM+aWVxwYjnrIY6Ez2rSlZFJDP9+ZXdAEwsL0pZDGbGWXOree5zb+adJ0/j7SceHkm+symUsrhEJPsoWRWRtBCJ9r+sTEVx/siT1bCGAYtI5kqMDjlz9oS0qGo+fVwJgYBRkBfguCkVANx010spjkpEsomSVRFJC+1dy8r00bNaUqACSyKS0w60hQG4+oyZKY7kaDMnlALw6s7mFEciItlEyaqIpIVEItlvz2qSCixp6RoRyUSv7DgEwKSK1A0B7kv2rq4qIqmkZFVE0kIo0evZz5zV1o4ozh29tt9gqWdVRDJZQ3MHAAsml6c4kqOlaBUdEclySlZFJC0E/fmkfVcDLiAad7T7RZKGoz0SI2BQlK+PPhHJPInRIVMqi1McydH+7bITACWtIpJcumITkbRwuNezr3VWve0jmbcaDHvruJqupkQkA3VEYxTmBwgE0u8zbOaEUv7pzfMxGNEIGBGR7pSsikhaSFTqLSvqo2e1uABgRPNW2zujGgIsIhkr3BmnOI1HhlSVFBB30DzC+gIiIgnp+4knIjnl8Bqo/fesjmT5Gq9nVcmqiGSm9kiM4oL0/QybMd6rCLyzqT3FkYhItlCyKiJpIeSvH9hnz2qJ37M6gmHAoUhMa6yKSMY6GIxQXZ5+lYATEmu/hqPDry0gItKdklURSQvBSP89q5WJntURDC8LRTQMWEQy1+b9bUwfl37FlRIK87zLynA0nuJIRCRbKFkVkbSQ6FntK5lMzFkdSYGlUCTW59I4IiLpzDnHtoNBjp1SkepQ+lToz6eNKFkVkSRRsioiaSEYiVGYF6Agr/ePpcPDgEfYs5rG871ERPrS0Rkn7qDCv3GXjhLLgt3xbD3RmBJWERk5JasikhZCkSilfcxXBe8iqCDPaGkf4dI1/ZxDRCRd7WwKAX2vRZ0OEj2rz2w8wAtbGlMcjYhkAyWrIpIWguEYZf0UPzIzKosLaB1Bz2p7Z//nEBFJV6/vagYOjzJJR92ncYzks1pEJEHJqoikhcEUP6oozh9RNeBgWAWWRCQzNYW85O+CBZNSHEnfaioPF386GIykMBIRyRZKVkUkLQQHUfyosmT4PauxuCMcjWvpGhHJSPtbwxTkGVVp3LNakBfgjhuWANCkZFVEkkDJqoikhfZIdMC5WJXFBcNeuiYU6b/asIhIOjvYFqa6rIhAwFIdSr8uOr6GiqJ89ayKSFIoWRWRtBAMxwbs9RzJMOD2xDquKrAkIhkoFIlRliGfX+PLCnl15yHqDwRTHYqIZDglqyKSFkKR6IAXYiMpsBRMJKvqWRWRDBSOxinMz4zPr5KCPF7efogL/6su1aGISIZTsioiaSEYiQ2uwNIwl645PAxYc1ZFJPOEo7GudUzTXajz8Od0p9ZbFZERyIxPPRHJeqFwdMBEsrKkgPbO2LAufkLqWRWRDBaJxrvWMU13Rd16gHc0hlIYiYhkusz41BORrBaPO0KdsQELLFUUe8ls6zDmrQbD6lkVkcwVicUzpmfVOdf1eOtBzVsVkeHLjE89EclqHdEYzjHw0jXF3pINw5m3miiwlCkFSkREuuvojFOYlxmXbWfOqe56vGW/klURGb7M+NQTkawWDPuJ5EBL1/jrCw5n3mpXgaUC9ayKSGaJxx2b97Uxe2JZqkMZlK++8wQe/vT5jC8t4LWdzakOR0QymJJVEUm5wRY/SgwDbhlWz6p/DvWsikiGaW7vJBKLM31cSapDGZSi/DyOm1LJ6bPGs25PS6rDEZEMpmRVRFIuNMghuiMZBqyla0QkUx0MRgCoLi9McSRDU11WRHP78JYbExEBJasikgaG3LM6jGHAoUgMMyjOkHUKRUTAK1b00OsNgJf8ZZKq0gIlqyIyIkpWRSTluuasDtSzmpizOoye1VA4SklBHoGADT1AkSxgZjPN7EkzW2tma8zsU/72CWb2mJlt9H+OT3Wscti9K3fy3cc2ADChLLN6VovyA0SiWmdVRIZvRMmqmY0zs9+b2Tr/y++c/r70zOzzZrbJzNab2SUjD19EssGge1aL8jGDlmEsXRPqjGnZGsl1UeBm59zxwNnATWZ2AvA54Ann3ALgCf+5pImV2xq7HmfaMODCvABxB9FhrI0tIgIj71n9AfCwc+444GRgLX186flfiNcAi4BLgZ+YmcbjiUhXz+pA80kDAaO8MJ+WYQwrC4Wjmq8qOc051+Cce8l/3Ir3nT0duAK409/tTuDKlAQoR4nG4tyzcmfX8/GlmZWsFvjrwkaUrIrIMA07WTWzSuAC4A4A51zEOXeIvr/0rgB+65wLO+fqgU3AmcM9v4hkj8H2rII3FLh1OD2rkZiSVRGfmc0GTgWWAzXOuQbwElpgcgpDk262N4a6Hp8+azyF+Zk1eyuxLmxn1KU4EhHJVCMZEzcX2A/83MxOBlYBn6LHl56ZJb70pgMvdHv/Tn+biOS44CCrAYNXZGlYc1aVrIoAYGblwB+ATzvnWswGN4/bzG4EbgSoqamhrq5uxLG0tbUl5TjZ6rld3mfd188t5pjKyKDbKl3adet2L/6Tv/4o/3ZWMfPHZ/ZncLq0azZRm46ObGrXkSSr+cBpwD8555ab2Q/of55Lb9+Gvd5q0xdi+lI7Jofa8UhvbIxgwAvPPUNggAvneLidHXuC1NXVDakdG/a3U5yP2r0X+veYO8ysAC9Rvcs590d/814zm+rfYJ4K7Ovtvc65W4FbAZYsWeJqa2tHHE9dXR3JOE622vpcPbz+BpdfdP6QiiulS7u+/sRGeMMrDvXN5R1s+fbbM7rIXbq0azZRm46ObGrXkSSrO4Gdzrnl/vPf4yWrfX3p7QRmdnv/DGB3bwfWF2L6Ujsmh9rxSM+0vUHpju28+cILB9z3V1tfpKG5g9ra84fUjre88jQzqkuprV0ywmizj/495gbzulDvANY6577b7aX7gRuAW/yff05BeNKLDr+SbnFBZg3/Tag9djL/7VcyBtjfFqamsjiFEYlIphn2p59zbg+ww8yO9TddBLzB4S89OPJL737gGjMrMrM5wAJgxXDPLyLZIxSJUVo0uHtnlSUFtIaHPgw4GImqGrDkuqXA9cCbzewV/8/b8ZLUi81sI3Cx/1zSQLs/RSJT14c+cUYVn37Lgq7nO7rNwRURGYyRXrn9E3CXmRUCW4AP4SXA95jZR4DtwFUAzrk1ZnYPXkIbBW5yzsVGeH4RyQKhSJSyQc4nrSzOp6V96AWW2jVnVXKcc+5Zep+SA94NZ0kzHdEYhfmBjB46++m3LOTyk6bylu8+zY6mEEtmT0h1SCKSQUaUrDrnXgF6G1PX65eec+5bwLdGck4RyT7B8ODXQK0oLqC1oxPnhlZd0juHklURyRzhzjjFGVYBuDczxpcCsPWAelZFZGgy/xNQRDJeKBIdVCVggMqSfOLucAXhwYjHHe2dg0+IRUTSQUdnjOKCzL/JVlyQx3FTKlhR35jqUEQkwyhZFZGUC0ZilAyhZxWgpX3w81bbO73EVj2rIpJJ2jtjlGTJ59bi6VVs3t+W6jBEJMMoWRWRlAuFhzJn1UtWWzsGP2815PfCDraIk4hIOujojGVscaWe5k4qY19rmANt4VSHIiIZRMmqiKRcKDL4IbqVJd5+LR2D71kNRbzEtjQLhtOJSO7o6Ixn7LI1PU0sLwLg1qe3pDgSEckk2fEJKCIZLTiEOavDGQac6Fkd7DlERFJt075WntqwP2vWJX3nydMAKMqCglEiMnb0iSEiKRcaQjXgymJvv6ENA/b2Hey8WBGRVPvMva8BMKu6NMWRJEdxQR7jSgs4FBr6OtkikruUrIpISnXG4kRi8UHPWe3qWR3CMOBg2O9ZzZJCJSKS/RZNqwTgXy4+NsWRJE91WSF7WzpSHYaIZBAlqyKSUkMtflQxrJ7VRDVg9ayKSGZ4ZuMBzp1XnTXVgAGmVpWwZndLqsMQkQyiZFVEUioxRHewvZ7FBXkU5QeGOGfVL7CURRd9IpK94nHHzqYQp88an+pQkmr+5PIhfXaLiChZFZGUSgzRHcqyMhXFBUOsBpw4h5JVEUl/ze2dxB2MKy1MdShJVVKYRzgaT3UYIpJBlKyKSEoNtWcVvOVrWoZRYEnDgEUkE2zY2wrAnInZUVwpoSBgRGJx1u9pTXUoIpIhlKyKSEolelaHMi+rorhgWEvXlGidVRHJAE2hCABTKktSHElyNTR7xZU++ssXUxyJiGQKJasiklKHe1YH3+tZWZw/5AJLxQUB8gI25PhERMZas38zLlFQLltMHecl3zsa21m+5WCKoxGRTKBkVURSKuj3epYNYT5p5ZDnrEaHlAyLiKTSdx5ZD0D5EObyZ4Lrzj6m6/HN976awkhEJFMoWRWRlAqFhz6ftLJkiD2r4VhWLf8gItltUkUxAONKC1IcSXJNrijmO+85CfAqu4uIDCS7btmJSMZJzCcd2jDgxJzVwb0nFImpZ1VEMsbkiiIK86owy76pC1ctmcnLOw7x8Oo9qQ5FRDKAelZFJKUSc1aHVmApn3A0TmfcDWr/YCSqnlURyRjBcJSyLBsC3N30cSU0BiMEw4MfISMiuUnJqoikVDASozAvQGH+4D+OKku8oXGDLQgcisSGNCdWRCSVgpFYVi+1Nd0vtNTQ3J7iSEQk3SlZFZGUCoWjlA4xkUxUyAxFB9ezGsryCz8RyS7BcJTyLL7BNrmiCID9rZEURyIi6U7JqoikVHAY80kri72e1cEnq1FKNQxYRDJEtg8DnuQnqwfawimORETSnZJVEUmp0DDmkyaGAYeGMAxYPasikinasjxZnVjuJaub9rWlOBIRSXdKVkUkpYLhGGVDTFaHPAw4rJ5VEckM0ViccDSe1RXMx5UWMKmiiNd2Hkp1KCKS5pSsikhKeUN0hzcMuL1z4GTVOUeoc+gJsYhIKgQTy3ll8ZxVM+O0Y8axo0kFlkSkf0pWRSSlguGhV+o93LM68L4dnXGcg5Is7qUQkezR5i/nks3DgAGmjytl0742moIqsiQifVOyKiIp1d459PmkZYX5BGxww4AT67hmcy+FiGSP7z+2AYC5E8tSHMnomlVdCsBO9a6KSD+UrIpISnlVL4eWSAYCRnlRPqFBDAMO+UPqSgqUrIpIegtHY9y7aicApxwzLrXBjLIFk8uBwzcURUR6o2RVRFJquJV6K0sKaB/ENU6oa/5Xdg+pE5HM9/L2QwD89LrTKMrP7htsiSrwic9oEZHeKFkVkZRxzhGMRIdV/KiyuGBQPatB/679UJfHEck2ZvYzM9tnZqu7bfuqme0ys1f8P29PZYy5bl1DCwCnz5qQ4khGX2IJsg/94kWe3rA/xdGISLpSsioiKZMoflQ6jF7PiuL8wc1ZDfs9qyqwJPIL4NJetn/POXeK/+ehMY5JutnR1E5JQR4TywtTHcqo6z4n97N/eC2FkYhIOlOyKiIpk+j1HM4aqJUlg+tZDY3gHCLZxDn3NNCY6jikb8s2H2TOxDLMLNWhjLruv2NRvi5HRaR3+nQQkZRJ9HoOZ87q1KpiDnY4nOs/YU3Mh1KyKtKnT5jZa/4w4fGpDiZXtUdirNvTwpuPm5zqUMZcoZJVEemDxsWJSMokelaHM2d1YU0F7VHY3dzB9HElfe6nAksi/fpf4BuA83/+N/Dh3nY0sxuBGwFqamqoq6sb8cnb2tqScpxssLU5RtyBa9pBXV3DiI6VKe36xbOK+dbyDsZZe0bEmyntmknUpqMjm9pVV28ikjJdQ3SHkUgeN6UCgPV7WgZIVlVgSaQvzrm9icdmdhvwQD/73grcCrBkyRJXW1s74vPX1dWRjONkg0fW7IFlq7j0vDM4cUbViI6VKe1aC9y16UmmThlHbe2pqQ5nQJnSrplEbTo6sqldNe5CRFKmq9dzGInkgppEsto2qHOUap1VkaOY2dRuT98FrO5rXxlde5o7AJhSVZziSMZWQV6Azlg81WGISJpSz6qIpExwBHNWq0oKmFBsrN/T0v85IlEK8wPk5+nenOQ2M7sbrzNropntBL4C1JrZKXjDgLcCH0tVfLlue2OIwvwA1WXZXwm4u4K8AJFBVHYXkdykZFVEUiYxRLesaHi9njPKA6zf23/PanskNqyeW5Fs45x7Xy+b7xjzQOQozjn++NJOFk2rJBDI/krA3VWVFLCjMZTqMEQkTamrQURSJhgZfs8qwIyKAJv3tfU7hCwYjg37+CIiY6G5vZOmUCfT+pl/n60W1pSzfm8rrR2dqQ5FRNKQklURSZlQeGQ9q9PLjUgszraDwb7PEYlq2RoRSWst7d5nYe3CSSmOZOztOtQOwFfuX5PiSEQkHSlZFZGUCUZimEFx/jCHAVd4H2Hr9rT2uU8oEhtWtWERkbHS4vcqVhQXpDiSsVdV4s3R/eNLu/jFc/UA/NPdL/PBn69IZVgikiaUrIrIqBhMdcdQOEpJQd6w52hNLQsQMNjQb7IaVSVgEUlrrR1ez2plSe7dWPu3y47vevzVv7wBwF9e3U3d+v1c/j/PcKAtnKrQRCQNKFkVkaRbs7uZRV9+hNW7mvvdLxgZ2XzSwjxj9sSyAXtWhzvMWERkLCTma1bmYM/quNK+f+fVu1q89WdFJGeNOFk1szwze9nMHvCfTzCzx8xso/9zfLd9P29mm8xsvZldMtJzi0h6qlu/n0gszmNv7O13v1AkOuJE8rgpFWzY23+yWqICSyKSxlr8ntWK4tz7rDI7cmTN7M89eMTz6rKisQxHRNJMMnpWPwWs7fb8c8ATzrkFwBP+c8zsBOAaYBFwKfATM1N3h0gWWl7fCMDzmw/0u19ohD2rAAtrKtjWGOpaBufoc0S1dI2IpLXdfpGhyRXFKY4k/XR0xlIdgoik0IiSVTObAVwG3N5t8xXAnf7jO4Eru23/rXMu7JyrBzYBZ47k/CKSfqKxOKu2NpIfMF7efohguPckEpKTSB43pQLnYNO+3tdbDYVjlChZFZE0tmV/G9OqinP2s+pvN7+J/3z3SUds+9a7FgPw9QfeGFQNBBHJTiPtWf0+8K9A90+RGudcA4D/c7K/fTqwo9t+O/1tIpJF3mhoIRiJ8Z7TZxCNO1b4vay9CYZHXql3YU0F0HtFYOccoc4YZRoGLCJpal9LB/e9spsTZ1SlOpSUmTupnKvPmMmnLlrQtW3JrAkANAYjLPjiX3l1x6EURSciqTTsKzgzuxzY55xbZWa1g3lLL9tcH8e+EbgRoKamhrq6umFGeVhbW1tSjpPr1I7Jkc3t+HC9VyjktJID/D4Av617GdvT+5yj/U0h8iOBYbdFW1sbW1e/SEEAnlj5BpPbNh/xeiTmiMUde3Zuo66uYVjnyAXZ/O9RJN396MlNALz9xKkpjiT1PvamufzgiY0ATCgr5NWvvJWTv/YoAJ/9w2s8/OkLUhmeiKTASLoblgLvNLO3A8VApZn9GthrZlOdcw1mNhXY5++/E5jZ7f0zgN29Hdg5dytwK8CSJUtcbW3tCML01NXVkYzj5Dq1Y3JkczvetX0ls6tbufrtF3LfrhfYFoxQW9vHBcYLf2PW9Gpqa08e1rkS7Xjs6mcIFRRSW3vWEa83BSPw2GMsPm4BtUvnDOscuSCb/z2KpLtyf3TJZUpWj1hze3xpAfl5AR785Hlc9sNn+636LiLZa9jDgJ1zn3fOzXDOzcYrnPQ359x1wP3ADf5uNwB/9h/fD1xjZkVmNgdYAGjFZ5EsEo87XtzayJlzvOFbS+dPZN2e1j7XyUtGNWCAY2sqWd/LhUzQL7o00iJOIiKjpbm9kwllheTnaTXBQMBY/81LefIztV3tsWja4eHRdy3fRkdnjGiPOaztkRjO9TpYT0Qy3Gh8Mt4CXGxmG4GL/ec459YA9wBvAA8DNznnVOJNJIts3NfGoVAnZ86pBrxkFWDZ5oO97h+MJKf40bFTytnXGvZ6UrsJRbyPmFKtsyoiaaopFGF8P2uN5pqi/DzmTCw7Yts3r/SKLX3xT6s57ksPM/+Lf+UbD7xBR2eM7z62geO//DB/eU1TPUSyUVKSVedcnXPucv/xQefcRc65Bf7Pxm77fcs5N885d6xz7q/JOLeIpI8V9V5Sepbfs3ri9CoqivN5btPRS9h0xuJEovGkFD86dkolAOt7rLeaSFZVYElE0tHzmw/w0Ot7crYK8GAV9tLrfMez9XztL2/wQ3+O6/O9fM+ISObTmBMRSZrl9Y1MrSpmxvgSAPICxtlzq3mul/VWu3o9k9Gz6lcE7jkUOOQvm6MLQRFJR7f8dR3gLbElfTO/ROffnTadX3748KqHd6/Y3vV4gf89ICLZRcmqiCSFc94yNWfOmYDZ4eLfS+dVs6OxnR2NoSP2b0/0eo5w6RqAmsoiqkoK1LMqIhmlM+bNs/zOVcMrMpcrLjtpKpedOJX/d8mxXdNLenpqw/4xjkpExoKSVRFJim0HQ+xrDXcVV0o4b4F3YdFzKPDh4kcj7/U0M46tqTiqZzVxDvWsiki6cc6xeV8bH1o6m9NnjU91OGmttDCfH197GlOrSsgLHL4Z+qP3n9r1+OkN+4nFVWRJJNsoWR2EaCzOz5+rp6NTw3RE+rKi3pueflaPZHXepHImVxTxbI9kNTHsLVm9nsdOqWDDntYjKkIe7r1Vsioi6eXZTQeIxOJMLO99HWrp288/dAZ1n6nl8pOmsfWWy/jEhfMBWLWtKcWRiUiyKVkdhOX1jXztL2/wyJo9qQ5FJG0tr29kQlkh8yaVH7HdzFg6fyLLNh8k3u2ud1fPapISyYVTKmgNR9nd3NHtHP682AINAxaR9NJwyPus6mtYq/TtwmMnM7tbxeAPnDsLgGc2aiiwSLZRsjoIWw4EAdiwVwtSi/RlxdaDnDn7yPmqCUvnT+RgMHLEnNKQn6wmq2f1uClecY0N3YYCt2sYsIikqf3++tMLJpcPsKcMpLrM653+n79tSnEkIpJsSlYHoX5/IlltS3EkIulp96F2djS2HzVfNWHpfG/d1e7zVoPh5A7RXTjZS1bXdUtWg5EYBXlGYb4+6kQkvTyyZg/zJ5cnpchcrus+j1VTtkSyi67gBqH+gJekblTPqkivXtzqzVftK1mdWlXC3IllRySroa4CS8m5UKsqLWBqVfERIyDaI7GkHV9EJFn2tnTw2s5m3rtkZqpDyRrff+8pALzR0JLaQEQkqZSsDkK9Pwx4W2NId+xEerG8vpGK4nyOn1rZ5z5L509keX0jnbE4cLhnNRnVgBMW1lQc2bMajib1+CIiyXDXC9sAOE1VgJPmrLnezdLXdhxKbSAiklRKVgcQicbZ0dTO3EllOAeb9mko8Gg5FIrw6Jo9NLd3pjoUGaIV9Y2cMXvCEUOxelo6v5pQJMYr/oVEsntWwZu3unlfG1E/IQ5FYkpWRSTtrNrexPRxJZx2zLhUh5I1plQWU1mczwZdp4lkFSWrA9jeGCIWd1yyaAoAG/dpKHAy1R8IcvszW3jv/y3j9G8+zo2/WsVPn9qc6rBkCA60hdm0r63PIcAJZ8+txuzwvNXQKMwnXVhTQSQWZ+vBoH+OqOaDiUjaOdgW4fiplb0WpJPhMTMqigv4zfLtnPvvT9AUjKQ6JBFJAiWrA0gMAX7zcZPJD5iKLI1QLO5YubWRf//rWi767zou/K86vvngWprbO/mHN83j+KmVPN9jPU5JbysHmK+aMK60kBOnV/H8poNAotczuYnksX5F4PV7vP+nwUiMkgL1rIpIemkMRqguK0x1GFln16F2AHY3d7Bsy8EURyMiyaAuhwEkiistnFzBnIllKrI0AtsPhnjvrctoaO4gP2CcPbea68+exUXH1zBzQingVfT7n79tpLm9k6qSghRHLIOxvL6RkoI8Fk+rGnDfc+dN5PZnthAMRwmGo5QleYju/MnlBAzW72nhspOm0h6JMamiKKnnEBEZiWA4yr7WMOOVrI6qz/7hNS5ZNKXf6Skikv7UszqA+gNBqssKqSotYGFNhXpWR+B/n9rEwWCEH1xzCi99+WJ+/dGz+ODSOV2JKsC586qJO28OpGSGFfWNnDZr3KCG8y6dX0007lixtdHrWU3yEN3igjxmTyzrWs81GIlqjVURSSs/f64egJNmDHyDT4am+w3Q1o4or+xoSmE0IpIMSlYHsGV/kDkTywBYUFPOjqYQ7ZHcrAh878od/PKNMM65Ib93X2sHf1i1i6tOn8EVp0ynsrj3XtNTjhlHcUHgiCVOJH21dHTyRkMLZ86uHtT+S2ZNoDAvwPObDhCMJL9nFeDYmgrW+xWB2yOxUTmHSCYys5+Z2T4zW91t2wQze8zMNvo/VZ52lK3Y2sTUqmLefuLUVIeSdZ761wu5/xNLucxv22hs6NcrIpJelKwOoP7A4WR1YU1FzlYEjkTj/MfD6/nb9ijPDiOR/PlzW4nG4/z9+XP73a8oP48zZk9g2WbNNckEq7Y24dzA81UTSgrzOH3WeJ7bdJBQeHTWQD12SgXbGr2bSt7SNZrtIOL7BXBpj22fA55wzi0AnvCfyyhp7ejk6Q37mT+5PNWhZKWJ5UWcNGMcH3/TPABaOqIpjkhERkrJaj/a/HklcyYlklXvy2VDDs5b/evqBg60hSnMg+88sn5IvautHZ38+oVtvG3xVGb7iX9/zp03kfV7W9nfGh5JyDIGltc3UpBnnDqE5ReWzq/mjYYWdjaFKCsanZ5V57zK3e2dWrpGJME59zTQc47FFcCd/uM7gSvHMqZc8+xG72ZvsQq/jarKEu8mZYuWwhPJeEpW+7HVrwQ810+wZlWXUZBnbMjB5Wt+uWwbs6tLue74Ql7b2cwja/YM+r13r9hOa0eUj72p/17VhHPneUNKX1Alv7S3ov4gJ88YN6QLr3PnTwS8ao0lo9SzCrB6VwudMadkVaR/Nc65BgD/5+QUx5PVEtVqv3z5CSmOJLslpho9+HpDiiMRkZHS+Lh+bN7vDfedO8nrUS3ICzB3Yjkbc6zI0updzaza1sS/XXY8czq38dTeAv7r0Q1cfMLAVfYi0Th3PFvPufOqOWnGuEGdb9G0SiqK83l+80HecfK0JPwGMhraIzFe29nMjRcM7iZEwknTq6goyqd1FKoBg3dTqSg/wMvbvcIaGgYskhxmdiNwI0BNTQ11dXUjPmZbW1tSjpMp/vRiO9PKjc2vrWA0VxTPtXbtKRb3Rn/9bd2+pLZDrrfraFCbjo5salddxfWj/kAQMzimW7XaBTXlvLLjUOqCSoFfLdtGSUEeV50+k5dXbOfmtx7LP971Eve9vIt3nz6j3/fe98ou9raE+c/3nDzo8+XnBThrTjXLNqvIUjp7eXsT0bgb9HzVhPy8AGfNrebxtXtHJZHMCxgLasp52f9/qp5VkX7tNbOpzrkGM5sK7OtrR+fcrcCtAEuWLHG1tbUjPnldXR3JOE4maI/E2PDYI1x71ixqaxeN6rlyqV37MuWFJ6ipKqa2dmnSjql2TT616ejIpnbVMOB+1B8IMn1cyRFDHBfWVLCzqZ1gODcm7R8KRbjvlV1ceep0qkq9YTVvWzyFE6dX8b3HNxCJxvt8bzzuuPXpLRw/tZILFkwc0nnPnVfN1oOhriFTkn6W1zcSMDh91tCLhy6d7w31Ho05q+D9P00UQkv28jgiWeZ+4Ab/8Q3An1MYS1b7y2u76Yw5Lj6hJtWh5IQls8fz6o5D/OqFbakORURGQMlqP7pXAk5IFFnKlYrA96zcQTga5wPnzOraZmZ85pJj2dnUzm9f3N7ne59Yt49N+9r4+JvmYja0RbnP9ZMZVQVOXyvqG1k0rYqKPpYh6s95/rzV0Rqie5w/bxXQ0jUiPjO7G1gGHGtmO83sI8AtwMVmthG42H8uo2D9nlbyAtZVl0FG1z/WzgfgS/etHmBPEUlnSlb74Jyjfn+wq7hSwoIa7yI4EysCb9jbOqQ1YmNxx69e2MaZcyZw/NTKI167YMFEzpwzgR8+sYlQpPde5v97ajPTx5V0rXc2FAsnV1BdVsjzGgqcliLROC9tbxryEOCE+ZPL+cYVi7jilNGZk7yw5nCyWqJkVQQA59z7nHNTnXMFzrkZzrk7nHMHnXMXOecW+D97VguWJNm8v415k8qGfPNWhueEaZV8eOkcCvMCtHaoKrBIptL4uD4caIvQGo4e1bM6a0IphXkBNmZYz+rGva1c+v2nWTp/Ind+6EwCAxRGAqhbv48dje187tLjj3rNzPjXS47lPT9dxp3Pb+Mfaucd8frKrY2s3NbEV99xAvl5Q78nEggYZ8+rZtnmgzjnsurL/cn1+/jhSx3csXk5oUiM9kiMjs6Y97jTe15dXsidHz7ziKQrnby+6xDhaHzYyaqZcf05s5MbVDfHTTl8c6VMBZZEJMWisTgvbDnI5SepaOBYumDhRH72XD1Prt/PO1WwUSQjqWe1D/X+sjVzJh25cHd+XoC5k8oyrmf1+49vxMx4ZuMB/vepwdUgvHPZNmoqi3jrot7n1yyZPYE3HzeZnz61meYea5n99KktjC8t4OozZg475nPnVdPQ3MHWg6FhHyPd7GgMcdNdL1HfHKctHKW4IMC0ccUsml7FBQsn8q5Tp/Ph8+YQiztu+NkKdqfhnN19rR1844G1FOQZZ8weXrI62moqi6gs9pJUFVgSkVRbta2Jjs44b1o4KdWh5JRTZo6jMD/A3cv7nrIkIulNXQ59qD/gL1vTo2cVvCGGq7Y1jXVIw7a2oYUHX2/gpgvnsaOxnf9+dD1nzJ7Qb69Y/YEgT2/Yzz+/ZSEF/fSM3vzWhVz2w2e57ektfOaSYwGvF/fxtXv51EULRjQn8dx53rzG5zcfOKqHOxPF447P3PsqATO+dHYx735b3xUKrzhlGlf/3zI+8LMV/P7j5zCutHAMI+3b2oYWPnrnShqDEf7nfacxoSw94urJzDhuSiUrtjaqwJKIpNwfXtpJWWEeFx2vZWzH0rjSQq5eMoP7Xt5NR2dsSGuCi0h6UM9qH7YcCFKYH2DauJKjXltYU86uQ+20ZUhF4O8/voGKonz+/vy5fPvvTmRWdRmfvPtlDraF+3zPr5ZtoyDPeN9Z/feMLppWxeUnTeVnz9Wzv9U73q1Pb6G4IMAN584eUdyzq0uZWlXM81lSZOnOZVtZXt/Ily4/nuqS/v/rHT+1kts+sITtjSE+/IsXhzTXeLQ8sXYv7/nf54nG49z78XO4dPGUVIfUr4VTvFERpbo4EZEUcs7x4GsNXLBwktZ9ToEJpYW0haMc96WHu9ZfFZHMoWS1D1v2B5ldXUpeL3M7E0WWNmbAUODVu5p5ZM1ePnL+HMaVFlJelM+P3n8qjaEI/3LPq8R7+eAOhqPcu2oHb1s8lckVxQOe418uXkg4GucndZtoaG7nvld28d4lM0fc62ZmnOPPW+0tzkyyZX8b//HwOi48dhJXLxnc0Oiz51bzw2tO4eUdh/jEb14iGut7maChikTjgz6ec47bn9nCR3+5krmTyvnzTeexeHpV0mIZLZcumsp58ydSWTL0asUiIsnyuxd3EIzEmDsp80cIZaIF3Wo/rG1oSWEkIjIcSlb70NuyNQkLu5LV9C+y9P3HN1BZnM+Hz5vTtW3RtCq+dPkJPLVhP//39Jaj3nPfK7to7Yhyw7mzjnqtN3MnlXPV6TO464XtfPuhdcQdfPT8uUmJ/9x5E2kMRlifATcG+hLzh/8W5gW45d0nDalY1KWLp/KNKxbzxLp9fOFPr+PcyJP2huZ23vLdpzjjW4/z+T++xjMb9/eZuHbG4nzhT6/zzQfXcumiKdzzsXOYUjXwDYx0cN6Cifz6o2f1esNJRGSsPLR6DwAfe9O8AfaU0XD5SVN58jO1ADy1YX9qgxGRIVOy2otY3LHtYJA5E8t7ff2YCaUU5QfSvsjSqzsO8fjafdx4wVwqe6yFed1Zx3DZiVP5r0fXs3Lr4ZUKnHP88vltLJpWyWnHjB/0uT550QIA/vLqbi47cSozJ5Qm5Xc4x1+PLpOHAt/x7BZe2n6Ir12xiJrKoSd61509i09dtIB7Vu7kvx5dP6JYDrSFufb25TQFIyydP5H7X9nN9Xes4MxvP8Hn//gaz2480JW4HgpFuOFnK7h7xQ5uunAeP37/aVoGRkRkiJqCERZNqzzqe1jGhpkxZ2IZi6dXct/Lu1IdjogMkSZP9GJXUzudMddrcSWAvIAxb1I5G9J8+ZrvPb6BcaUFfHDpnKNeMzP+/d0nsnp3M/9098s89MnzGV9WyIr6RtbvbeU/h9gDOG1cCdefM4s7nq3nY29KTq8qwPRxJcyuLmXZ5gN85Lyjf490t3FvK//16AbeekINV54yfdjH+fRbFrCvNcyPn9zMpPKiXv9OB9Ic6uT6O7wKw7/6yFmcMXsCHZ0x6tbv56HXG/jzK7u5e8UOJpQVcsmiKSzfcpCdTe189+qT+bvTZgw7dhGRXLa/Ncz5CyamOoycd/6CSdz29BY6Y/F+C0eKSHrR/9ZebPErAc/pZ37JwprytJ6zumpbE3Xr9/OxC+ZR3kc11MriAn78/tM42Bbh5nu9+au/XLaNcaUFvPOUoa9H9q+XHstfPnEei6Yldz7jOfMmsnxLY1LnbI6FaCzOZ+59lbLCPL71rhNHtFasmfHNKxdzyaIavvbAG/zl1d1Den9bOMoHf7GCzfvauO0DS7qWnCkuyOPSxVP44ftO5aUvXcxPrzuNc+dV8+dXdnGovZO7/v4sJaoiIsPU2tHJvtaOXos1ytg6fmol0bjjr/6wbBHJDEpWe9G1xmo/y6UsqKmgobmDlo7OPvdJpe8/voHqskI+cE7/804XT6/ii5cdz9/W7ePbD63l4TV7uHrJzGGVdy/Kz+PEGckvvHPuvGpaw1FW786swgg/fWozr+5s5htXLmZSRdGIj5cXMH5wzamcMWsC/3LPK3zvsQ0EB1GRuqMzxt/fuZLXdjbzP+8/lfMX9L7On5e4TuVH7z+Nl750Mcu/cFHarqMqIpIJ6g8EiTs4YVplqkPJeZcu8irYb0rzUXEiciQlq72oPxCkojif6n6q2aZzkaUV9Y08s/EAH3/TPMoGscbkB86ZxaWLpnD7s/XEneO6swZXWGmsnD03MW/1QIojGbw3drfwgyc2ctlJU7n8pKH3UveluCCP225YwltPmMIPntjIm75Tx13Lt/VbIOkf73qJF+oP8t9Xncwliwa33ExxQZ6GSYmIjNChkHdDO13XpM4lhfkBygrz2LyvjdW7mlMdjogMkq5Ge1F/IMjciWX9DttcWOMVX0rHocDfe2wDE8uLuO7swSWdZsZ/vOck5k4s47ITp3JMdXKKIyXLpIoijq2pYNkYFFlyzrF+T+ugeiz7EonGufneV6kqKeAbVyxOYnSeqpICfnztafzxH89lzsRSvvin1Vzy/ad5dM2eI6oFx+KOf/7dK/xt3T6+eeVirjx1+HNmRURk6A7465krWU0PnXHHg683cPn/PMsTa/emOhwRGQQVWOrFlv1BzpzT//DHmeNLKS4IsCHNelaf33yAZVsO8uXLTxhS5daqkgIe/vQFjGBa5ag6Z141v31xO+FojKL80alIG4s7/u2+1dy9YjuF+QGWzqvmLSfUcNFxNYNariUYjrJ6VzP3rtrJ2oYWbr3+9FG9QDntmPHc87FzeOyNvdzy8Dpu/NUqzpw9gc+//ThOnjGOz//xNR54rYEvvP04rk2z3nIRkVywZX+QvIAxc3x63QTOVUvnVfPkem/5mtue2cJFx9ekOCIRGYiS1R46OmPsbm7vd74qQCBgzJ9czsZ96dOz6pzje49toKayiPefdcyQ31+Yn74d7efOq+YXz2/lle2HOMsfFpxMnbE4N9/zKve/upsbzplFXiDA42v38uSfVvNFVnPi9CrecnwNbzlhMidMrSQWd2zc18YrOw7x6o5DvLLjEBv2thL3OzavP3sWbx3kkNuRMDPeumgKbz5uMr9buYPvPbaRd/3keY6bUsG6Pa188qIF3HiB1vYTEUmFzfvbOGZCaVp/v+aSn3/oTAA+/8fXuHvFDm5/ZkvS1oUXkdGhZLWHrQeDONd/caWEhZMreC6N5lE+u+kAL25t4utXLBpWgaR0dtbcagLmrbea7GS1ozPGJ37zEo+v3cdnLz2Of6j1krsvXX48m/a18djavTz+xl6+/8QGvvf4BiZXFNEWjhKKxAAYV1rAyTPG8dZFUzh15jhOmlFFdfnICyoNRX5egGvPmsUVp0zntqe3cPszW7jxgrn881sWjGkcIiJy2Ob9bcyb1Pua7ZI6//yWhdz38m5uf6ZeyapImlOy2kP9/oErAScsqKngjy/vorm9k6qS1C72HY7G+O5jG5hWVcx7z5iZ0lhGQ1VJAYunV7Fs80H++eLkHTcYjvL3v1zJsi0H+caVi7m+2zxfM2NBTQULair4x9r57G8N8+S6fTyz6QDVZYWcMnMcp8wcx6zq0hEtS5NM5UX5/PPFC/nkRQvIC6RHTCIiuSgai7NxXxsXHjc51aFID5Mri7n2rGP4zYrtqQ5FRAagZLWHLYNYtiahe5GlJWO4xEc87th6MHjEENQ3GlrojDm+/a4TR21OZ6qdM6+anz1bTygSpbRw5P90D4UifPDnL/L6rma+e/XJvOvU/tcTnVRRxNVnzOTqDLgZoERVRCS1/vjyLpyDaVVaYzUdlRXlE4rEiMcdAX1niqQtJas91B8IUlNZNKglXxLL12zY2zbqyer2gyF+/9JOXt7exKs7DtHS4VWrLS3M48TpVXx46RzOmD2Bi47P3ju4S+dN5P+e2sKLW5t408Le1wqN+ZNGB0rW9reGuf6O5WzZH+Qn15426CVdREREBmNdg1fT4tLF+n5JRxXF3nXezqb2tFsFQUQOG3ayamYzgV8CU4A4cKtz7gdmNgH4HTAb2Apc7Zxr8t/zeeAjQAz4pHPukRFFPwrqDwQH1asKMH1cCSUFeWwYxeVrDrSF+dHfNnHX8m3E4o5jp1Ry2UlTOXnGOE45ZhwLJlfkTC/aktnjKcgz/v2htfziuXqC4Rht4SjBSJRgOEpbOEpHZ5zC/AALa8o5fkolx0+t5LipFZwwtZJxpV5l3l2H2rnu9uXsae7gjg8u4fwFvSe+IiIiwxGOxrh31Q7mTiqjpnLgavIy9t60cBLffHAtf13dwMfepEKEIulqJD2rUeBm59xLZlYBrDKzx4APAk84524xs88BnwM+a2YnANcAi4BpwONmttA5FxvZr5Bc9QeCg+5lCwSMBTWjUxG4LRzl9me2cNvTW+iIxrl6yUw+/ZYFOf2lV1qYz3vPmMlzmw6yvy1MWWE+U6uKKSvKp6won/KiPMqLCghGoqxtaOHJ9fu4d9XOrvdPrSrmuCkVrN/TSms4yq8/eianzxq74dsiIpIbfr9qJ60dUT68dE6qQ5E+zJ9cTl7A+N7jG5SsiqSxYSerzrkGoMF/3Gpma4HpwBVArb/bnUAd8Fl/+2+dc2Gg3sw2AWcCy4YbQ7IdCkVoDEaYO8ieVYAFkyt4euP+Affb09zB7uZ25k0sp6q072JMkWicu1ds53/+tpEDbRHetngKn7nkWFUT9H3zyhOHtP++1g7WNbSytqHF/9NKSWEet35gCYunV41SlCIikqticcevlm0D4JMXqSJ7ujIzrl4yk7tXbOejd77I7TeckeqQRKQXSZmzamazgVOB5UCNn8jinGsws8QkyunAC93ettPfljbq/eJKcycNPlldWFPOH17ayaFQpGuYaU+v7TzE+29bTlvYm2daXVbI3EllzJlYxtxJ5cz1f77R0MJ/PbKe7Y0hzpozgds+cBynHjN+5L9YDptcUczkimIu6GOOq4iISDJt3t/Guj2tvOPkaTkzTSdTffPKxWzY28rja/fx6o5DnDxzXKpDEpEeRpysmlk58Afg0865ln6W8OjtBdfHMW8EbgSoqamhrq5upGHS1tY24HGe29UJwP4ta6jbu3ZQx+3Y7yWgv3v4GY6dcHQV3h2tcW5Z0U5JvnHDKUUcaHc0BOPsaW7m4d1NtESO3H9mRYB/Ob2IEyd20LzlVeq2DCqMMTOYdpSBqR2TQ+2YHGpHkeT5zXJvOZR/rNXQ0nSXFzB+8aEzOPGrj/LUhv1KVkXS0IiSVTMrwEtU73LO/dHfvNfMpvq9qlOBff72nUD3NT9mALt7O65z7lbgVoAlS5a42trakYQJQF1dHQMdZ+Uj68kLbObdl9ZSkBcY1HHnN4X43qonKZs2n9pua3SCd3f1M/+3jIqSYu752Dm9Vptrbu9ky/42tuwPUlaUx1tPmJLWJdQH044yMLVjcqgdk0PtKJI8z246wHnzJ3L81MpUhyKDUFFcQHFBoGv0m4ikl8FlZL0wrwv1DmCtc+673V66H7jBf3wD8Odu268xsyIzmwMsAFYM9/yjof5AkGMmlA46UQWvInBZYR4be1QE3tEY4trbluMc/PqjZ/VZFr2qpIBTjxnPu0+fwaWLp6Z1oioiIiJ923WonU372lg6f2KqQ5EhKC/Kp7VDyapIOhpJz+pS4HrgdTN7xd/2BeAW4B4z+wiwHbgKwDm3xszuAd7AqyR8U7pVAt4yhGVrEsyM+TUVbNjb1rVtT3MH77/9Bdo7Y/z2xrOZP1nFkURERLLd/z21mYI84x0nT011KDIEkyqKWb2rGecc/UxnE5EUGEk14GfpfR4qwEV9vOdbwLeGe87RFI87th4Icu686iG/d+Hkcp5c7412PtAW5trbX6Ap2MldHz1Lw4BERERyQCgS5ZfLtvGe02cwY3zvo6kkPV1/9iy+8KfXeWbjARVkFEkzwx4GnG32tnbQ3hkbcs8qwMKaCg60Rdiyv43rbl/OrkPt/OyDZ2iivoiISA4IR2Oc8OVHADh77tBvektqvf3EKQD8buWOFEciIj0pWfXV7/eXrRlGsrqgxhvme82tL7Blf5DbPrCEM+dMSGp8IiIikp5WbW0CYGJ5IZefpCHAmaaqpIBxpQU8+FoDjcHIwG8QkTGjZNW3pWuN1aHPL11YUwFAYzDCT649jfMXaAiJiIhkDjPbamavm9krZrYy1fFkmhVbGzGDv32mluKCo5exk/RmZtx6/RIAbnsmzdYMFMlxI15nNVvUHwhSUpBHTWXRkN87taqYq5fM4KLja3jLCTWjEJ2IiMiou9A5dyDVQWSilVubOG5KJZXFBakORYbpzDkTmF1dyo7GUKpDEZFu1LPq27K/jTkTy4ZVBc7M+M/3nMwli6aMQmQiIiKSrr7zyDqe3XSA044Zl+pQZIQ6OuM88FoDuw+1pzoUEfGpZ9VXfyDIoulVqQ5DREQkFRzwqJk54P+cc7f23MHMbgRuBKipqaGurm7EJ21ra0vKcVLllX1RfvxSGICS0B7q6g6mOCJPprdrqlTlRdgDvOuHT/Lv55cQ6NGBoXZNPrXp6MimdlWyCkSicXY0tfOOk6elOhQREZFUWOqc221mk4HHzGydc+7p7jv4CeytAEuWLHG1tbUjPmldXR3JOE4q7Gvt4MZbngTgh+87lctPnEogkB5rdGZyu6bSknOifPLul/nbun0cd+rZTBtXcsTratfkU5uOjmxqVw0DBnY0hYjF3bCWrREREcl0zrnd/s99wJ+AM1MbUXpzzvH5P7xOJBbnL584j3eePC1tElUZvvKifK5eMgOAppCqAoukAyWrHF62RsmqiIjkGjMrM7OKxGPgrcDq1EaVvpqCEZZ883GeWLcPgMXTK1MckSRTojd1ze6WFEciIqBhwAC80dCCGcybPPRla0RERDJcDfAnv8BgPvAb59zDqQ0pPb228xBX/XQZ4WgcgIc/ff6wCjNK+lo8rYqSgjzWNihZFUkHSlaB5fUHVXJeRERyknNuC3ByquNIdy9vb+JdP3m+6/nzn3vzUXMaJfMFAsa8yWVs2teW6lBEBA0DJhKNs2pbE2fNmZDqUERERCQNtUdi/N3/Hk5U3/j6JUpUs9iCyRU8u+kA2w4GUx2KSM7L+WT1tZ2H6OiMc/bc6lSHIiIiImlo5bZGnIMPnDOLrbdcRmmhBqZls4+cN4fK4gLef9ty2sLRVIcjktNyPlldXt8IwJnqWRUREZFuDoUi/MOvV3H9HSsA+NzbjktxRDIWFk+v4ifXnsauQ+3896PrUx2OSE7L+VuDL2w5yLE1FUwoK0x1KCIiIpJGPnLnSlZtawLgw0vnqEc1hyydP5GTZ1SxcmtTqkMRyWk53bPaGfPnq85Vr6qIiIgcdvszW1i1rYlF0yp55csX8+V3nJDqkGSMnT23mjW7m/ncH17TcGCRFMnpW4Sv72omFIlpvqqIiIgAsLMpxGf/8BrPbTpIWWEet35gCeNKNfoqF/1D7TxCkRh3Ld/Go2/s5TOn5qU6JJGck9M9q8u3aL6qiIiIQHN7J5+8+2XO+48neW7TQapKCnjqXy9kuqr+5qxxpYV848rF3Pvxcwh3xvjd+kiqQxLJObmdrNYfZP7kciaWF6U6FBEREUkR5xwf+9VK7n91NxXF+XzjysU8/7k36/pAADh91gT+6aIFvLo/xu3PbEl1OCI5JWeT1Wgszov1jVpfVUREJMd997ENvLClkRvOmcXrX72E68+eRVlRTs+Ukh4+eO5sZlUG+OaDa1m/pzXV4YjkjJxNVtfsbiGo+aoiIiI57aXtTfzP3zZx8owqvniZiihJ74oL8viX04uZWF7Ix361kn2tHakOSSQn5Gyyurz+IIAqAYuIiOSolo5Orv7pMiaUFfKj959GYX7OXhbJIFQVGT+97nR2NLXznYe1/qrIWMjZT+XlWxqZO7GMyRXFqQ5FRERExlg87viX371CNO748uUnMHNCaapDkgywZPYEls6fyPObD/LMxv0451IdkkhWy8lkNRZ3rKhvVK+qiIhIDjrYFmbuFx7i8bX7uOaMmVx56vRUhyQZZMHkcnYdauf6O1bw739dl+pwRLJaTlYPWNvQQms4qvmqIiIiOSYWd3z816sAeMfJ07jl3SelOCLJNB88dzYb9rbyzMYD3Pr0FnY1tXPijCrueLaeM2aP58NL57BktjpERJIhJ5PVF7b481XnKFkVERHJJT94YiMvbm3iO+85iauWzEx1OJKBZk4o5VcfOYu2cJQv/ul1/vzKbh58vQGAh17fw0Ov7+FfLl7IzAklzJtUzkkzxqU2YJEMlqPJaiOzqkuZUqX5qiIiIrnixa2N/PCJjSyZNZ53nzYj1eFIhisvyucH15zKLX93Eg++3sBZcybgHFx3x3K++9iGrv2uOn0G37nq5BRGKpK5ci5ZjccdL25t5JJFNakORURERMZIR2eML923mqL8AL/48JkEApbqkCRLlBTm8Z7TD9/8+NvNb+LB1xvY3xrmWw+t5d5VOzGD/3j3SZjp353IUORcsrpuTyvN7Z2aryoiIpJDHnitgXV7WvnaOxdRXpRzlz8yhvLzAlxxile060NL5/CNB97gF89vZXl9I5+4cL6Gn4sMQc5VAz68vqqSVRERkVwQDEf53mMbmDOxjA+cMyvV4UgOyQsYX7r8BP7j3SeSZ8b/+/1r3PjLlfxt3V4teyMyCDmXrL6w5SAzxpcwfVxJqkMRERGRUbZ+TytX/XQZu5vb+bfLjtcwTBlzeQHjvWccw4OfPJ8PnDOLFVsb+fAvVnLt7cvZ09yR6vBE0lpOJavxxPqqqgIsIiKS9f740k4u/cHTrN/bym3XL+Gi41WvQlKnpDCPr1+xmBe/+BZuvnghz28+yNn//gQ7GkOpDk0kbeVUsrpxXxtNoU7Onqu1r0RERLLZz5+r5zP3vsqciWU88ukLeMsJSlQlPRTkBfinixbw/y45FoCL/vspPnPvq0paRXqRUxUGEvNVVVxJREQkO720vYmv3r+G13Y2c87cam79wOlUFBekOiyRo9x04XwuWVTDL5dt4zfLt/PHl3by9SsWc93ZmlctkpBTPasvbDnItKpiZozXfFUREZFsEo87fvZsPe+/7QUOtkX42jsX8euPnqVEVdLa/MkVfP2KxTzz2Qs57Zjx/Nt9q3l+04FUhyWSNnImWXXOn686t1rFFURERLLIzqYQ196+nK8/8AbnzpvIfTct5YZzZ5OntVQlQ0ytKuH715xCeVE+H/vVKu54tp71e1pVMVhyXs4MA24IOg60RTRfVUREJEus3tXM0xv3879PbqYzHuc/330SVy2ZoZvSkpFmjC/l/k8s5R/veolvPPAGAHMnlfHbvz+byZXFKY5OJDVyJlld1xgDUCVgERGRDPf8pgP89OktPL1hPwBnzpnAN69czMKaihRHJjIycyeV8/CnL2BnU4jH39jLtx9ax3n/8STXnT2L954xk3mTysjPy5mBkSK5lazWVBYxq7o01aGIiIjIEATDUeoPBHl5exOrtjXxwGsNlBTk8f8uOZZ3nzaDKVXqdZLsMmN8KR9cOocz51TzrYfe4GfP1fOz5+opzA9w3JQKTphayQnTKlk0rZLjplRSVpQzl/SSY3LiX7ZzjvVNcd50nOarioiI9GRmlwI/APKA251zt4z2ObvPxeuMxdl9qJ1tB0NsPRhky/4ge5o72N3czqZ9bYQisa59J1cUcflJU/nKOxYxvqxwtMMUSakTplXy64+cxZYDQV7f2cya3c280dDCw2v28NsXdwBQkGdcfEINM8eXMr6skEnlRYwvK6CyuIDSwnxKC/O8P0X5lBbkEcjAudw7GkPUrd9Hc3vnEdtnjC9l+vgSjp1SQXlhfkb+btK/nEhW6w8EaQ47LVkjIiLSg5nlAT8GLgZ2Ai+a2f3OuTdG87y3PLyOh15qx1Y8ya5D7cTih5PXssI8po4rYUplMe89YyaTKoqYOb6Uk2ZUccyEUt14lpxiZsybVM68SeVceep0wLvZs6elg5Vbm7h7xXZe3dHM42v3EYnGBzxeZXE+1eVFlBXlUVqYT5mfyJYV+s+P2p5PaVGe97Mwj/KifEoK88gPGPl5AQryjLyAURAIDDpZbI/EWL+3lWd3dfLK4xtoDEY42BahMRhhe2OI5vZOovE48Th0xuMMps5UYX6A2dWlFOYHKM7PY+aEUooLApgZzkHAoPbYySyeXkmeGWZGwCBgRiDQ7bEZ5j/O87frMyd1xjxZTcXd2+X1jQCcpeJKIiIiPZ0JbHLObQEws98CVwCjmqzOri6jqsiYM30c7zx5GsdUlzJrQimzqsuoqSzSxaFIP8yMqVUlvOPkEt5x8jTAS2BDkRj7W8Mcau+kub2TUDhKKBIj1BmjPRIlGI5xKBThYDBC0H/tQFuEYGOIUDhGMBIlGI4SH2YR4oBBfiBAfp51JbP5AS/p64w5OmNxOmPxI0ZL8PpGxpUWUF1WyPjSQhbUlDO7uozC/AB5Ae845UX5XHjcZOZMLOt6WyQaZ83uFhqDYTbvD7J5fxttHVFicS+RX7b5IHHnun6XtnAndy3fPtwmPyKZDQSOTGzzAkZBXoCCQCLx9X5nM8jreo+X+HrbjbweiXJeIHG8IxPnwwk1/muHt1nXfhzx3oaGMHUta7y2T/xdBLy/i4D/95HXLfbDMRl5fZznyLi851UlBaPeGTimyWqq7t6+sOUglYXG3G7/wEVERASA6cCObs93AmeN9knfd+YxTA1tobb21NE+lUhOMDPKivJHPH/VOUc46iWUiYQ2GIl2JbOhiLct6iefsbgjGj/8uDPmiMbiROOOaDxONOaIxR0F+QEK/eS1ID/Agsnl7N+6ng+980IK84deNKogL8CZcwbfERUMR1lR38ielo6uJNY5L7bE48T2uHPE490ed3s9Fj9632jM+107Y+6I98acO+Ic3nZH7IhzO68HORb3j+u/5m+PO4friqP746NfS7w3HI6yct/Orr+baNwdMXolWRZPr+SBfzo/6cftbqx7VlNy9/br71zMH0sadZdWRETkaL19OR51VWNmNwI3AtTU1FBXVzfiE7e1tSXlOHIktevoULtCkf9nfM8XjKFnFS1QWNjO888+nYzQBsWAqYPdOa2LLluPn0dqawtTXl50xLZEIuwlyhAHP7n1fsZxXY8d3nbXbR9Hz+2OgkDnqP+fGOtkNSV3b6tKC5hTlTfapxEREclEO4GZ3Z7PAHb33Mk5dytwK8CSJUtcbW3tiE9cV1dHMo4jR1K7jg61a/KpTUdHNrXrWCerunub4dSOyaF2TA61Y3KoHXPei8ACM5sD7AKuAd6f2pBERETGPlnV3dsMp3ZMDrVjcqgdk0PtmNucc1Ez+wTwCF7xw58559akOCwREZExT1Z191ZERCTNOOceAh5KdRwiIiLdjWmyqru3IiIiIiIiMhhjvs6q7t6KiIiIiIjIQNK6KLOIiIiIiIjkJiWrIiIiIiIiknaUrIqIiIiIiEjaUbIqIiIiIiIiaUfJqoiIiIiIiKQdc86lOoZ+mdl+YFsSDjUROJCE4+Q6tWNyqB2TQ+2YHLnWjrOcc5NSHUQm03dz2lO7jg61a/KpTUdHJrZrr9/NaZ+sJouZrXTOLUl1HJlO7ZgcasfkUDsmh9pRUkX/9kaH2nV0qF2TT206OrKpXTUMWERERERERNKOklURERERERFJO7mUrN6a6gCyhNoxOdSOyaF2TA61o6SK/u2NDrXr6FC7Jp/adHRkTbvmzJxVERERERERyRy51LMqIiIiIiIiGSInklUzu9TM1pvZJjP7XKrjyRRm9jMz22dmq7ttm2Bmj5nZRv/n+FTGmO7MbKaZPWlma81sjZl9yt+udhwCMys2sxVm9qrfjl/zt6sdh8HM8szsZTN7wH+udpQxp+/m4TOzrWb2upm9YmYr/W19/j82s8/77bzezC5JXeTpZajXOX21o5md7v99bDKzH5qZjfXvkk76aNevmtku/9/sK2b29m6vqV0HMJzryWxp16xPVs0sD/gx8DbgBOB9ZnZCaqPKGL8ALu2x7XPAE865BcAT/nPpWxS42Tl3PHA2cJP/70/tODRh4M3OuZOBU4BLzexs1I7D9SlgbbfnakcZU/puTooLnXOndFueotf/x367XgMswvtO/4nf/jKE65wB2vF/gRuBBf6fnsfMNb+g9zb4nv9v9hTn3EOgdh2CIV1PZlO7Zn2yCpwJbHLObXHORYDfAlekOKaM4Jx7GmjssfkK4E7/8Z3AlWMZU6ZxzjU4517yH7fiJQjTUTsOifO0+U8L/D8OteOQmdkM4DLg9m6b1Y4y1vTdnHx9/T++Avitcy7snKsHNuG1f84b4nVOr+1oZlOBSufcMucVgvklOf4Z2ke79kXtOgjDuJ7MmnbNhWR1OrCj2/Od/jYZnhrnXAN4/3GAySmOJ2OY2WzgVGA5asch84euvgLsAx5zzqkdh+f7wL8C8W7b1I4y1vTdPDIOeNTMVpnZjf62vv4fq62HZqjtON1/3HO7HO0TZvaaP0w4MVxV7TpEg7yezJp2zYVktbdx2CqBLGPKzMqBPwCfds61pDqeTOSciznnTgFm4N0dXJzikDKOmV0O7HPOrUp1LJLz9N08Mkudc6fhDaO+ycwu6GdftXVy9NWOat/B+V9gHt5Ungbgv/3tatchGML1ZNa0ay4kqzuBmd2ezwB2pyiWbLDXH0KA/3NfiuNJe2ZWgPfBcpdz7o/+ZrXjMDnnDgF1eHMs1I5DsxR4p5ltxRt2+WYz+zVqRxl7+m4eAefcbv/nPuBPeMN6+/p/rLYemqG2407/cc/t0o1zbq9/0zkO3Mbhoehq10Ea4vVk1rRrLiSrLwILzGyOmRXiTTa+P8UxZbL7gRv8xzcAf05hLGnPr7B2B7DWOffdbi+pHYfAzCaZ2Tj/cQnwFmAdaschcc593jk3wzk3G++z8G/OuetQO8rY03fzMJlZmZlVJB4DbwVW0/f/4/uBa8ysyMzm4BVUWTG2UWeUIbWjP/Sy1czO9r/zP4A+Q4+SSKh878L7Nwtq10EZxvVk1rRrfqoDGG3OuaiZfQJ4BMgDfuacW5PisDKCmd0N1AITzWwn8BXgFuAeM/sIsB24KnURZoSlwPXA6/58S4AvoHYcqqnAnX4luwBwj3PuATNbhtoxGfTvUcaUvptHpAb4k7/aRD7wG+fcw2b2Ir38P3bOrTGze4A38CqK3uSci6Um9PQylOucAdrxH/Aq4JYAf/X/5Kw+2rXWzE7BG3K6FfgYqF2HYEjXk9nUruYVghIRERERERFJH7kwDFhEREREREQyjJJVERERERERSTtKVkVERERERCTtKFkVERERERGRtKNkVURERERERNKOklURERERERFJO0pWRUREREREJO0oWRUREREREZG08/8Bh39SR/mmug0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 45001/45001 [06:58<00:00, 107.57it/s]\n"
     ]
    }
   ],
   "source": [
    "state = env.reset()\n",
    "for step in trange(total_steps + 1):\n",
    "    \n",
    "    # reduce exploration as we progress\n",
    "    agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "    # take timesteps_per_epoch and update experience replay buffer\n",
    "    _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "    # train by sampling batch_size of data from experience replay\n",
    "    states, actions, rewards, next_states, done_flags, weights, idxs = exp_replay.sample(batch_size)\n",
    "    \n",
    "\n",
    "    # loss = <compute TD loss>\n",
    "    loss = compute_td_loss_priority_replay(agent, target_network, exp_replay,\n",
    "                           states, actions, rewards, next_states, done_flags, weights, idxs,              \n",
    "                           gamma=0.99,\n",
    "                           device=device)\n",
    "\n",
    "    loss.backward()\n",
    "    grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "    opt.step()\n",
    "    opt.zero_grad()\n",
    "\n",
    "    if step % loss_freq == 0:\n",
    "        td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "    if step % refresh_target_network_freq == 0:\n",
    "        # Load agent weights into target_network\n",
    "        target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "    if step % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        mean_rw_history.append(evaluate(\n",
    "            make_env(env_name, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "        )\n",
    "\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "              (len(exp_replay), agent.epsilon))\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean reward per episode\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(td_loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"TD loss history (smoothened)\")\n",
    "        plt.plot(smoothen(td_loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 1000.0\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state = env.reset()\n",
    "    reward = 0\n",
    "    while True:\n",
    "        qvalues = agent.get_qvalues([state])\n",
    "        action = qvalues.argmax(axis=-1)[0]\n",
    "        state, r, done, _ = env.step(action)\n",
    "        reward += r\n",
    "        if done or reward >=1000:\n",
    "            print('Got reward: {}'.format(reward))\n",
    "            break\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got reward: 1000.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAlFttZGF0AAACoQYF//+d3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE2MSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjAgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz0xMiBsb29rYWhlYWRfdGhyZWFkcz0yIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFjZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTMgYl9weXJhbWlkPTIgYl9hZGFwdD0xIGJfYmlhcz0wIGRpcmVjdD0xIHdlaWdodGI9MSBvcGVuX2dvcD0wIHdlaWdodHA9MiBrZXlpbnQ9MjUwIGtleWludF9taW49MjUgc2NlbmVjdXQ9NDAgaW50cmFfcmVmcmVzaD0wIHJjX2xvb2thaGVhZD00MCByYz1jcmYgbWJ0cmVlPTEgY3JmPTIzLjAgcWNvbXA9MC42MCBxcG1pbj0wIHFwbWF4PTY5IHFwc3RlcD00IGlwX3JhdGlvPTEuNDAgYXE9MToxLjAwAIAAAAIrZYiEACv//vZzfAprRzOVLgV292aj5dCS5fsQYPrQAA1PkAAAAwAVOr8dejkBDVIAAAMACxAB0hJQ8g8xExVioErxTwJjEALq5cLMAAmcN+8Z/4M6AEreL9ddnIIBNPgxbteKWoIL4SyIvaYet4cCa5HSUsNyhFR/8zVOP+sX+u9pd+CoVuVIN6PXvQYTdq7Pg+GmsdPLfrMl0/FMrBAsXtOwPZJLJjNKJ7FfuvYHBWrqQYkBKA65a9n/+YLxeTwzOrQL16LA++4YBLxAvgqsaAha/V5rBIWFPsTlswrEVEZ3Lkl4Cic9z7rr2fFSwa7ZdPPAq/J5KDSAmH8icBMz0V5l0gnieW1D5u/V09IxuBmddARZpMADPR4NebigIwUKS6+U+GKjJHCr+UdFKus1jK8IQGRfB8daWysTuZffB/oC/A2Y/fPLzfWKHw/JqXRb4CjLjyJ1DY//9xWNfdUNyh0oK5CqQQuWGhvwWkjvZ1iX/gd31ySBTjx9ihFcbf0sFNRLzT6szEh83yXaB1GUnR5aRGQmQb6x8fL/ARCSDyo7u4xtaZtpsaeSwTW3ylW1prcgH18DS2rvM5fv2HwKib+N7KR0PRb6FR2N+6UGXYlp2vgcrjqmCvRqriD0CStXnAsk5ZMI+XI3EBQACJDzGMq60ENfqU+XSGIkGzC1p9QrYdhVCxHJNZdvMCo6QQr9cgfJJ4q/JoKOMGvmZmdWu8IwETAAAAMAABbxAAAAs0GaJGxCP/3hAAAEFA6HYckA+E/Dnh0cBSKuCiYMfrmw6yzhmoh/gA65Ah/t9rLXKZJpTwdcYXvJFmN2LHbTFrxGMneXb1duC31229mcYazDbwr4txwPqYvkHgSsKIYaJqXSclilh5O+jHRLrSNQwjuWq7e2Lwuh1VbTC4Wef3suxEvdBBaUWS7KPaADwDATmZu+L5lmHuslJ2z1tQBBqY/jByaCcHSUaIuna/14c29Je5wcAAAAQ0GeQniEfwAAFr5LsJeKyTTJB84C3vQCX9JZmS87Y27qZbzSBsHcG4kh8+U68jDhPp1gn7jS+S4O0xEGT/X/LKvsOWEAAAA8AZ5hdEf/AAANh6ulg1d0euAO1ddNVFeUBHvOkHR1IIFgAbQAp6PU7Vis7RNQ2HU5rcb1pYW6iUzskqTgAAAAOgGeY2pH/wAAI7HL6MH7sMr01nNpCwYPq2Pw0c6jx9HIRKboAHuT/9dOJ4BGwnVAefreyHKCILx1/o0AAADBQZpoSahBaJlMCFf//jhAAAEM9o0+WAUk7kp0pD8StN7ItxcbrHA7x0c7N890sWQAWtY16zI0nlRE4HS2zFAk/cUH0VhOs19lyAk/XCfSVRPsBcTITSX2MkoeUlsMdnquCUe0Fre2wyy5VK56FkpfKDC+Rp6KrucIbxUpQaAZJYBp0hkWl98eAuTlhpVkYESefHHNeeDFB70Mgv+SsPJWV9CSr3gSrN2+GbEGrpqZEiOfbQCS4+q2iIwF4odD/ytIqQAAAENBnoZFESwj/wAAFrUrNEjnxAATrCRL+IhkTkIgDY9JFDTl4L+04Em92XatYhP8JbUr8TX7wxy5ImX4KdCtjcLcHMv9AAAAOwGepXRH/wAAI6np09SQAiWLdmSuQVBMtUJBgC4b3O9jKFJVjS2x2LJdwLwwhqM3rdauqKvv9/QkWejBAAAAMQGep2pH/wAADYIw+zFQNcaz/XdzgvhJAtkdJRhBGgAQ1nuDV18E2PVxDz5UUkr+duAAAABOQZqsSahBbJlMCEf//eEAAAMD9cxEAfEpmsf+mh6bfgefEiRoALsOU2sqgUyw0JxbcxiS12BKTw93Sj5FziKk2+TcZKacuUXEq7sUzP6mAAAAPEGeykUVLCP/AAAWLFC29NSEnwKmuL4ssSraJHDBXj6UJcq7iQF4jfUzJkQy+D3mQAbPca+829r43JTyEwAAACIBnul0R/8AAAUgkUderY0AIdDp4/bTBsu3vSjPm9JSDgmDAAAALwGe62pH/wAAIr8fkHB+2KUl+cVc/d8Jp7bpOSkNuebBkHbl0KDLv8L9kqY4/48GAAAAcUGa70moQWyZTAhf//6MsAAARhEF3cQAn5gCy+2IWFWxixlfXXbrLoyi0DV9EbSmT+Uly8+oyUvFBT36yvNT+FVSOF7IoqXYwTOFtay7oLJi9iDPF9DYi3rmCwZu0KMlRhHBTbweYRml1WomNgSM4/hnAAAAKkGfDUUVLCP/AAAWtTLUQoZ6s5P47OFD4+E7Y6Qx42qjA0uOOCHSSX05IQAAAB0Bny5qR/8AACKyPL+kbgJsz7Ps6Wo05zLCQGg5IQAAAERBmzNJqEFsmUwIV//+OEAAAQ05v79jl9D1yHKOG5E43Xa+H16ZQAQQR0VpFyH0Z2n1iZI5tlx9n/X1jrrqTiJ5cNcVwAAAACtBn1FFFSwj/wAAFrUrN2uLFRNW8Hq4hhkDUAHCA1Fh6rEzJ0yXP20CF2zAAAAAHQGfcHRH/wAAI8MXYaiqcNn3p2g0F1HZrmQmtp4NAAAAHAGfcmpH/wAAI6lpMARCqDwZp1+y5JiRr/E8g7oAAAB3QZt3SahBbJlMCE///fEAAAMCn+759ZJXOnIAbxtNBQ6E9/IxcQnm0kBrSmd17Lp7SHE1HO4+dNJ199SG024T4x1LK4Apgh2H1XJKT0lAc+g5uNqa9uUEZhPWEc7jBXjUvLk0AJzdyoPxEOH8rUOmr2XNXpx2hdgAAAAvQZ+VRRUsI/8AABa1XBiI3PWDgAWkDXDR97kH+ni7JQ77hzPiKEFb4j3MngQPbZkAAAAiAZ+0dEf/AAAjrD0d64xINO6g2Cfz67C5jjbTYPrZlLMkwAAAACkBn7ZqR/8AAAUeRntNxnamxqk13raadv8mYAEPuafFRDcfDQVJ6tbwYQAAAHJBm7tJqEFsmUwIT//98QAAAwKfRT4D/Op4iJ2M0W16fOKyN6cF7hGq8CIqkmVgu8jPgPxSoHe9l5FthWICmfM1XGfDzESynO/1fesnv8vxEyNqoYWDGSprTev1z5od9u0HIAGraCplGTSD3SV533IGjTEAAABAQZ/ZRRUsI/8AABa1XBim4yIhPED6VOXi4V+o5+T1nVm5tiKmnsw0b3ACDumpJh9xvHuVvu2GUQuxJFGOJQljtwAAACcBn/h0R/8AACPDQlb1EKAneOPiN8NWhe8BdiC+jUKHFBO3gbbRJMEAAAAcAZ/6akf/AAAFHzTVJeZTGByo5IzUbavyo6gYMAAAAFVBm/9JqEFsmUwIV//+OEAAAGTGTLZ9KHIJK/D7OVr4FKZjs9bdbWFQvgBQa9GavupGvAGB3+rXImuWEaHC5furr7zbJV4g4qnCtF7w6LWYUM4Pzgl5AAAAIUGeHUUVLCP/AAADAznM8YLFDYmuHT/43/bDKZ3B1+eqCQAAACUBnjx0R/8AAAUcUmqFSwMklspihf96XaAD6ixwL/5gn31NfuN6AAAAMAGePmpH/wAABR5SQtUQQSLg1h0Xx0qcwY+noh3btgAJxoQ1cpMLUuYyoPUVxv8k4AAAAEdBmiNJqEFsmUwIR//94QAABBP2vAf5swpbhjjrZbfosfHQfKBiNYV85ULI+scRBbkEERSMPNRB8LniugyZADm/gHQtk6dMwQAAAEJBnkFFFSwj/wAAFrxPijwR1cnM5K3NROZJIJppyq3y4s36G4Ma+/x97ABEHebIeb59IM+2hoR6jiIoPvWIz41MHJAAAAAjAZ5gdEf/AAAFIJOuZLFDzQ7/4wmrPsEZOJ/SAxhvtaDstuEAAAAmAZ5iakf/AAAFHkFo6KoJ29NwUgSixRjmD+S974iOuRtAGc2c3gwAAACdQZplSahBbJlMFEwr//44QAABDPq+GowFDOq7p+PT+S1DeNCXI01UZqUiETGrfYw7IZX/T2cIYJTAXCN/k+xZXf3227SPBByTCGF0uGDRL6lvmoPZsWaM8qIXKzl21/ytP3B9dZXsYsSWuosJPR1QFOZCaF4gZlMyBRSjSTc6AK9wESPeqUAUQgJrnqJ4TtSbu0E2s4UB6SkwhZY2gQAAACsBnoRqR/8AACOjbmwrwGLbxy6CnOTpoFQXeyKxoG13k0WeS56tVM7LbF23AAAAqEGaiUnhClJlMCEf/eEAAAQTfzlAp3Z4fDnK8PvRiLPcANfambEQ2WQ63hXeIxRBI+WNkt9mvOlhqmAzhEw/f8ZBkTe8x8qd6gFf4NFBj/dvjxI3gmBpXxtUfGFQRnaekUGHT1lOswHr90Bj27NvXdnvL84D8nNnh37dqVz0HhesAN2Z0n/HYjnHMK2jepD49Ulp4nfDC6/iWevggCZc8LuL7fqo66GV0QAAADdBnqdFNEwj/wAAFrUrJv+ry3AA4ruUfOduBh/9x3i7aMZ5Qn8d40CVKZTnVVX1puuA3vASaCtnAAAALAGexnRH/wAAI6wU6Q5+VSQ/ccfNPjRQN1+WI+/34sQE6P+oP7mOuU0syvwYAAAANAGeyGpH/wAADYSVLQyUn1LYdz8b6aBM1m0EdGYN0HPYADjdCtmeSfk8JQlSB1MYZbIjhHwAAABDQZrMSahBaJlMCFf//jhAAAENUQ8XmAqrBNZ/WrYmRnCPshDbcSc+g4KjOWmx9Y4f7HASDZvFBg+p1phsUph8Bi0VIQAAAElBnupFESwj/wAAFrUzqoQAIr9AkcK9ZoLLoYvJ/IwMjYXZkttQdyZkliKjuipuM/IOr81xeF6l1s3KDOPeeJ/8eKuD2eX9WrBgAAAANQGfC2pH/wAABR5OeJc+6IOyY1kFu7AOmiAeAyb2RHwAFxP2ImETKTn9jyuAwuh++xj1fqjAAAAAUkGbEEmoQWyZTAhP//3xAAADAA2PmfQbmSRX6mSi/E1PBjXPYetTOzsuXQBL1v1ky9NnVpQsI1Uu/l77eMzOI5DAT+mmdtv49DsXTOUaBsxFfEEAAAAyQZ8uRRUsI/8AAAMDOMrDKky/pqbrtgJgGwVgATtrGt/XXEAF9DO1meuy62SM0XrF2zEAAAAdAZ9NdEf/AAAFH8vu4WAV79AJYXeCSp1JWwom/JMAAAAXAZ9Pakf/AAAFHTAT+orrLor+z8xqYMAAAAB8QZtUSahBbJlMCF///oywAABGDl6dwDV9ShMofkZPS9perQfQWTvo1xR41w3cb3IYXQuIq4w1vuoSZMTF1IWf39ArPugE31jZTqUil3kT/U4eyZC8wrcxKQhpFeibelSwDeOch296GGjRtYIDEeeEeDCqDCXUZZkFtRTcgAAAADNBn3JFFSwj/wAAFrk6SUALD1KhaB6knT53c8+y2V6ROcvep5B/xjqRBNsBxmpkYBWYNt0AAAAeAZ+RdEf/AAAjw0JaVz5LZ9Zo14Bydox+stSMS5JgAAAAKwGfk2pH/wAAI78EK/qJ+O4HAAueq39NfqrRnkxNuq9r2llzslUEFQ/FnJAAAABOQZuYSahBbJlMCF///oywAABGAv5owCknrhMo3wBsaeWRy3q3mmgHS9LjUaysPZkatZzyQeJdsPb/5ohIgWYiSFP/US382dTmL6kZmaIvAAAALUGftkUVLCP/AAAWtSs5tKtN0CqZbnJEczK2aADmgiqsvGCcb1fSE37pI0/swAAAABcBn9V0R/8AACPDF3VTivJhp7wELvEtuQAAACUBn9dqR/8AACPHvYtRivBN/KWGLAAuer5szl0zBz522K6TvFJBAAAATkGb20moQWyZTAhf//6MsAAARge5AEKtqMfZvIhW3cee6LCoFTT2orYOtQSe73EaOsWXPuNirWXfXJ1G43yuOXZOLlBDe4E/RryC2iWsgAAAADVBn/lFFSwj/wAACG2CV90mP43ezyHIEz7PFzlZ9EiNEoAQnCNR5Vxo/++q5mONWNI0a4+OSQAAACIBnhpqR/8AAA2CpdE2FFPDmDncRkvRR9GDsru+nnM5aiEqAAAAZ0GaH0moQWyZTAhf//6MsAAAGoks9+uASvEMS0Duvxh4EByZRUGG3AcAF8v5bCePkdZN9rw3JMj8xJ4a/mEMtwlLdMbFCfd2CdnS8kjyaThD1qFCMmKblyxH/360f0PWXX3L+VKnPf0AAAAsQZ49RRUsI/8AAAhnbSGCvZfK5b2MCS75kMkIZ8BlsDSHj5UY7OfIhu39DkkAAAAoAZ5cdEf/AAANfgDYRRjMPbPBvlrVUokcIHpG+IAEHU1N3Tsmtn/1RgAAADUBnl5qR/8AAA15SvnH8hcySIDvLL/8erTc7ZUaVZmwAJxogVRv0AsRqzpkR59G1NNtBLhgQAAAADZBmkNJqEFsmUwIV//+OEAAAGdIe1Wi6aA/gRfXw7HGWAIsKwkgMTNbbt8bmSxLed6eVLbKF8EAAAA1QZ5hRRUsI/8AAAhvIeffN/hvkbOvXpsBxVRKAO0zNGS568wAhTvF3KJlfO0WF9sbSGgZtuAAAAAlAZ6AdEf/AAANh6+kWFk50YRu8J9V3JRNLuFsrCiovYTjbGlKgQAAAB8BnoJqR/8AAA109vcjxuKPt9YeeH0T9ih6emVyx73QAAAAdUGah0moQWyZTAhP//3xAAADAp8EXC4CoptR/5BbsVGuR4pyH3Xd93CZ4/eD5Jp/UOObVQl2c2aQ2XfURF2XMxFc/07b2PYSdmPwaqCBOJcPfKF2KjSg+TyTWqovD9Kq26bjNHo0waosyvfqabjTX9wCdxw0hwAAACpBnqVFFSwj/wAAFrxDzcxeSWxvnyRDeXofXu+Hs+Scx3TgN64FVMXTbcEAAAAgAZ7EdEf/AAANhd0z+r9rvlaGDa0QzJbSDVmX6SSJ2zEAAAAhAZ7Gakf/AAAjscwRfB9k4YI0LieUzQTjzMUdoMjD08gJAAAAaEGay0moQWyZTAhf//6MsAAARge5AEKtqMetmfHbVOW7uFDWNs4AT41Gcw4yK5OfAxgaDjy6FxlDlZT5UG2zXRJapzd796+OUXWh4ItLZJ8Ep2WXhevYq7hBAnJWIZ8NffrEipFG7Io2AAAALEGe6UUVLCP/AAAWtVhVzAHAERvZR0cJ2CPw43xwfpIC6K2sNfghdFXXTA7cAAAAIwGfCHRH/wAAI6w+bjiOl+9d0B9hrU7vRF6yf3pXXxho5wlRAAAAHAGfCmpH/wAABRrKoQi8/11kRAg8oI/wgzSZnwYAAABEQZsMSahBbJlMCGf//p4QAABFSJcgGrYTCv+4YDL8SOMOpEx86kOSUlGuvYBzx4vp7dusuSmxeQ19+idY75Zddsm3Q8IAAAA2QZswSeEKUmUwIZ/+nhAAAEVFJilKrQBB6XC0NMcrC3Z6LyfKG/ZBkroIq+6LHXPUU19T5GHNAAAAIEGfTkU0TCP/AAAWvEPNzEutfZEnrDxUPyu+9p4L0IkZAAAAGAGfbXRH/wAADX9PaZoprN1rkOx3WMoNqQAAACEBn29qR/8AACK78pgAca9RU6EclyqVgKOBMbEuMzzRQd0AAAAiQZt0SahBaJlMCF///oywAAADAIgF7LHHo62oYUKUobdDwAAAABhBn5JFESwj/wAAAwAsWIebx1BE9eG3UEEAAAAdAZ+xdEf/AAADABprumtD3Dm7SGR2Pi06cPGLLMAAAAAeAZ+zakf/AAADAEV+CE/tXAAuer3sbqQwg9qNjaFtAAAAO0GbuEmoQWyZTAhf//6MsAAAAwFkxUECzbD0eLgCjtQRR6xlF5Rp/GyoRJCljaIbL8Zwinw/s7hxSEfBAAAAJEGf1kUVLCP/AAAWuTPhpCzWxfJVXL3+e/9QTAlLcIUh1eTtwAAAAB0Bn/V0R/8AACPDP9RJVlv4CVuBsw/OnLvOHbr23QAAABsBn/dqR/8AACO+/o9ixiHZjJRCROBEHx7k2zEAAAAuQZv8SahBbJlMCF///oywAABECNZwA6BoYnkoD8qrQ7+Ov1URj4fr0lU9FOfMWAAAABlBnhpFFSwj/wAAFiVakkVB4DX7tA1Ox3mVAAAAIAGeOXRH/wAAIsNAEy696GQ0Gf8KSQqWmTccW8sTxFtwAAAAFQGeO2pH/wAAIsfHJ/KedsE7+cxCywAAAC9BmiBJqEFsmUwIV//+OEAAAQVRPJXL+Vp4PeYv9ALC9xBimkAHOCsXJJRzZ6y1lQAAADBBnl5FFSwj/wAAFrO/HfO+SAEZDopNXzZmlVJywGsS+ejIlh5hRnUecJFKq5xMJbcAAAAaAZ59dEf/AAAjwxd1j48rpBv8mqZ7UFKH1JMAAAAsAZ5/akf/AAAjroIXzMfdqUYUAAAshGZsORl7BfxXneqsrV8pw5yrSsWBbMEAAABQQZpkSahBbJlMCE///fEAAAMCjfOClrh7tCuRpAEQMp/oINCX/muNYIGiu/w2Zfhl3C+g8oBaMv/c9uCLmg65xHlZgPSS/hEAj35LGvwptx8AAAAlQZ6CRRUsI/8AABYsT47dLfrBwAJkeSKNaVdp5v/4IGP0JUvj/QAAADwBnqF0R/8AACPA0YZgwz6ACMADcRxhrGUIYAnslz2WuU6MlXwq6Qt8as3hReP/artpkCl08AhlSp9h5bcAAAAVAZ6jakf/AAAivx01cIDzXNVpiAypAAAAWkGaqEmoQWyZTAhX//44QAABDPt8q2AcSwzhyLatgDVDXyMiZpG2HGI039StXxibKD28YTFFj4qeY6WgNJ0BXwQEGzQ+pdje0CMIDnFgpSyHJvPAmhIc1HZQwQAAABpBnsZFFSwj/wAAFrxDzbcV4zxLkb9Qz1wwcQAAABIBnuV0R/8AAAUbAKnCXfrABvUAAAAYAZ7nakf/AAAjvwQnEsnD5AW1gULDIYOAAAAAMUGa7EmoQWyZTAhH//3hAAAEFNVT/aL+oerpyK/foM8/eK0bvZkbM/ABsFfAo7xSQsAAAAAoQZ8KRRUsI/8AABa1N6UQdVP3AAfuZC6LY0ngSUqla5YNwtgk7NNQQQAAAB8Bnyl0R/8AACPDF2ipxhPQQSI8QUgQ34JlonLiiG24AAAAFgGfK2pH/wAAI8ji7aj5kKs071/AEfAAAAAtQZswSahBbJlMCGf//p4QAABFVSTgBfoUd3rWIALzE5a0jH7etw3iQWvrWFDBAAAAOEGfTkUVLCP/AAAWtS3NUAcocVVgp1WafnDIq1vqx6jl6ErOn/ZIfpvFKA/dMVGUfV5VZlrXFtmBAAAAKwGfbXRH/wAAI8MCLUTtmcAC6ADVpG2ebBl9JCHX/BMTzV01/Vh8mRiHOSEAAAAdAZ9vakf/AAAivxwJcq06dHAUkGtcBqmZa4BcO3AAAAA9QZt0SahBbJlMCGf//p4QAABDUgagewGNABzRvEDgA/LgNfyKM4jZ4rp1WcX8FbX/YSBveKxY07P3WkR1QAAAADFBn5JFFSwj/wAAFr6iSkQd70BwAH7mKGoeSjern1YXYm4MXNN5voioIiEJf5V1BR8HAAAAKwGfsXRH/wAAI8MDnRJxhPSvkAC1EulruHVL+Xm9LlRMSk0z8dRMa/iQJJgAAAAgAZ+zakf/AAAjuc36wbElFsZwco5MY0ENkZDK3tX2s5IAAAAuQZu4SahBbJlMCGf//p4QAABDVRVQPaNpKgeijLEx5eYwxGAA4Jv+mbOR+l6y4QAAACxBn9ZFFSwj/wAAFixPIFYckc4jADc0VuHyNpfC8vPhcXoqH0fXeJ5jfkByQAAAABUBn/V0R/8AAAMB4HuTLMlQPXngU0EAAAAfAZ/3akf/AAAivxwJlktutllcTcuywGWzCN6ym7e2zQAAAEJBm/xJqEFsmUwIZ//+nhAAAEVFIQLO5CEjlQ4AHD/iHPB7c2kTBkBTxG9HMec9BULKv8fB757Eu3n2GoAzsrKgfqYAAAAZQZ4aRRUsI/8AABa94E9ZVjpFVFSYyjMhQQAAAB0Bnjl0R/8AACPDF3VZLsTPAbgl5njoUoyTAfX8GAAAABwBnjtqR/8AACPHxtglopMivVDgATM/YwZkTiFBAAAALkGaIEmoQWyZTAhn//6eEAAARVUNZqguRG0BcHL2VTqt6ewI3hNW3bgGsTv6qykAAAAoQZ5eRRUsI/8AABa8Rt/a2GqOAFkRTPfDDm4TP851syAOBN0mppdgwAAAABQBnn10R/8AACO6U4F9Pz626ACygAAAABcBnn9qR/8AACO/BCgPXH1dV4KZo8gwYQAAAClBmmRJqEFsmUwIZ//+nhAAAEVOYsgASmDi1DAaJgkSCYGLH6x4fAl+QAAAABRBnoJFFSwj/wAAFrUrQyD60/eBHwAAACoBnqF0R/8AACPDF3VZJhsOSABaiMzYOAFWbWA5H3hWNW/kBnBfHOZd2zAAAAAcAZ6jakf/AAAjx74wUOA5VVj0wAJmfsYMyJxCgwAAAB5BmqhJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAsQZ7GRRUsI/8AABa1K0MyiXo7gACZqARi1u2LCe4RTkpTdcM9dDM/i6Pgu2cAAAAaAZ7ldEf/AAAjwxd1aIoKA2ML2tydYOvQgIEAAAAbAZ7nakf/AAADAEVcYl+i8p04zuzIZ3zUjO2YAAAAJEGa7EmoQWyZTAhn//6eEAAARVUNaYYAfpFpd6A0TBj6fZtbMAAAABRBnwpFFSwj/wAAFrUrQyD60/eBHwAAACkBnyl0R/8AACPDF3VZNhyABdABojcxE2DB5Lcpak/lWdyzxF0JjsPgwAAAABMBnytqR/8AACPHvYwaHKqkX4UEAAAAHkGbMEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAAB1Bn05FFSwj/wAAFrmllYkAHHdRxs45B9lWV6XPgQAAABABn210R/8AACPDF3VQAJOBAAAAEwGfb2pH/wAAI8e9jBocqq3qdgwAAAAeQZt0SahBbJlMCGf//p4QAABFVQ1mq7aJgx8r6sl4AAAAFEGfkkUVLCP/AAAWtStDIPrT94EfAAAAHQGfsXRH/wAAI8LivvsWMQCzjiD++pDvLv6H23gwAAAAEwGfs2pH/wAAI8e9jBocqqRfhQQAAAAeQZu4SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAHkGf1kUVLCP/AAAWtStDJvnMgGTENW+g+HWkoxCtuAAAABgBn/V0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAeAZ/3akf/AAADAEWEIE3VouAxSXVTvWtQiGg0t9sxAAAAHkGb/EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnhpFFSwj/wAAFrUrQyD60/eBHwAAACkBnjl0R/8AACPC4r77FjEAsdXFMABs9XcGpgulYeTEuLwzbdP461GduAAAABMBnjtqR/8AACPHvYwaHKqkX4UFAAAAHkGaIEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABVBnl5FFSwj/wAAFrxDz4Qrk5vEEfAAAAAOAZ59dEf/AAADAAADAakAAAATAZ5/akf/AAAjvwQrwHKL1EdgwQAAAB5BmmRJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4AAAAAUQZ6CRRUsI/8AABa1K0Mg+tP3gR8AAAAcAZ6hdEf/AAAjwxd1U4p6uQmwAH7E0o5xVWtswAAAABMBnqNqR/8AACPHvYwaHKqkX4UFAAAAHkGaqEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABVBnsZFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ7ldEf/AAADAAADAakAAAATAZ7nakf/AAAjvwQrwHKL1EdgwAAAAB5BmuxJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4AAAAAUQZ8KRRUsI/8AABa1K0Mg+tP3gR8AAAAcAZ8pdEf/AAAjwxd1U4p6uQmwAH7E0o5xVWtswAAAABMBnytqR/8AACPHvYwaHKqkX4UEAAAAKEGbMEmoQWyZTAhn//6eEAAARVUNbmmgDlG8E6UKMmnO2iYMeEeW1s0AAAAuQZ9ORRUsI/8AABa1P2UEtQ5bOIAC6AlMciLxL+QiAMHJcbGhtnTlh7tD0mF2zQAAABgBn210R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAeAZ9vakf/AAAivxvqoUSrxL3+WW+2T+5f1AFdT/gwAAAAI0GbdEmoQWyZTAhn//6eEAAARVUNZqu2iYMsmgBwERBKUrOAAAAAFEGfkkUVLCP/AAAWtStDIPrT94EfAAAAKAGfsXRH/wAAI8MXdVOKerkaNQAQdUH3PD24my7PzH5jlaXWbqom2YAAAAATAZ+zakf/AAAjx72MGhyqpF+FBAAAAB5Bm7hJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAArQZ/WRRUsI/8AABa1K0Mm9tiZxAATrCAmLN8kJV+9zGqvuIAzjdUkgZC8GAAAABgBn/V0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAnAZ/3akf/AAADAEU5SvcgAtRGZsI2KvqoIcO4Ny4nXg0a4BLy+KW3AAAAHkGb/EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnhpFFSwj/wAAFrUrQyD60/eBHwAAACoBnjl0R/8AACPDF3VTinsI3AAIfc0/YUUGaUVEeLG7YBMZYZkQItF1HbgAAAATAZ47akf/AAAjx72MGhyqpF+FBQAAAChBmiBJqEFsmUwIZ//+nhAAAEVVDW5poA5RvBP1rOY4TtomDHhHltbNAAAAFUGeXkUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bnn10R/8AAAMAAAMBqQAAABMBnn9qR/8AACO/BCvAcovUR2DBAAAAHkGaZEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnoJFFSwj/wAAFrUrQyD60/eBHwAAABsBnqF0R/8AACPDF3VTinuGHbg/6tEuciVwbZgAAAATAZ6jakf/AAAjx72MGhyqpF+FBQAAAB9BmqhJqEFsmUwIZ//+nhAAAEVVDWartomDInjydrZhAAAAFUGexkUVLCP/AAAWvEPPhCuTm8QR8QAAAA4BnuV0R/8AAAMAAAMBqQAAABMBnudqR/8AACO/BCvAcovUR2DAAAAAHkGa7EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnwpFFSwj/wAAFrUrQyD60/eBHwAAADEBnyl0R/8AACPC4xvuxYxALrDFceTN/aJAAHvyWnNPke/w/rtER3vMmK6BNSDF1rbgAAAAEwGfK2pH/wAAI8e9jBocqqRfhQQAAAAeQZswSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAALUGfTkUVLCP/AAAWtStDJvbYjuAAJk/reg8Fu2KljubNjLGvvRBmuKLUaos9swAAABgBn210R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAnAZ9vakf/AAADAEWqQgAugA0Rw2ubBg8n4Ehov06kNJRLjFVwW2zAAAAAHkGbdEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBn5JFFSwj/wAAFrUrQyD60/eBHwAAACMBn7F0R/8AACPDF3VRT15zjIAF0CkNRmA4JV1PyuWJe7Z44AAAABwBn7NqR/8AACPHstxLgOTKkKSACZn7GDMicQoIAAAAHkGbuEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAACxBn9ZFFSwj/wAAFrUrQycCbuAE0wkTxOAnrPOcuYV8NGj/B+ezWi6pGOLbMAAAABgBn/V0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAnAZ/3akf/AAADAEWqQgAugA0Rw2ubBg8n4Ehov06kNJRLjFVwW2zBAAAAHkGb/EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnhpFFSwj/wAAFrUrQyD60/eBHwAAABwBnjl0R/8AACPDF3VRUM0BFfOIACdMB+u59CcHAAAAHAGeO2pH/wAAI8ey3EuA5MqQpIAJmfsYMyJxCgkAAAAeQZogSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFUGeXkUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bnn10R/8AAAMAAAMBqQAAABMBnn9qR/8AACO/BCvAcovUR2DBAAAAHkGaZEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnoJFFSwj/wAAFrUrQyD60/eBHwAAABIBnqF0R/8AACPDF3VRUNEkwoIAAAAcAZ6jakf/AAAjx7LcS4DkypCkgAmZ+xgzInEKCQAAAB5BmqhJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAlQZ7GRRUsI/8AABa1K0Miub9yoBADEkpTtACBEkiSyOecPMaFswAAABcBnuV0R/8AACPDF3VTivJhp7wELvEtuQAAABoBnudqR/8AAAMAGl0JWSy2Txo6x634OeP/ZgAAAB5BmuxJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ8KRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ8pdEf/AAAjwxd1UVDRJMKCAAAAHAGfK2pH/wAAI8ey3EuA5MqQpIAJmfsYMyJxCggAAAAeQZswSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAHEGfTkUVLCP/AAAWtStDIrm/cqAQAxJgSoaYtt0AAAAXAZ9tdEf/AAAjwxd1U4ryYae8BC7xLbkAAAAaAZ9vakf/AAADABpdCVkstk8aOsfetNy2LZgAAAAeQZt0SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGfkkUVLCP/AAAWtStDIPrT94EfAAAAEgGfsXRH/wAAI8MXdVFQ0STCggAAAA4Bn7NqR/8AAAMAAAMBqQAAAB5Bm7hJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAcQZ/WRRUsI/8AABa1K0Miub9yoBADEmBKhpi23AAAABcBn/V0R/8AACPDF3VTivJhp7wELvEtuQAAABoBn/dqR/8AAAMAGl0JWSy2Txo6x9603LYtmQAAABZBm/lJqEFsmUwI//yEAAADAAADAMCAAAABnGWIggAP//73aJ8Cm1pDeoDklcUl20+B/6tncHyP6QMAAAMAAAMAABW3pGWGQnQv8mIAAAV8ALIF2ESEgFLG8KvSQuZmJ+CxgAEqMq9lujCie47hpX3fTd8aV31j/paq1WRMVTXlvgAADPbhIJKd1zC0fntssNdQ6nRbl2PZjDD4qzxWZsYza39ggr8aa0DwaAn0SJsAvDmdQO4zEQDwMAQVnDfuhSaCLuU5v1mB+3Nt91dk+EjOMS3NlUElr7+M5XJEMuzbr2GP9uVF8AOryTX5aqgWvVWKks6zjN1p5r1Hp0mbfohMd+8UflZqYkWpbHdZq9jtdIdniP5hiZufsbM3xsGpkm+xIBIfFDOOH4hebdIJwZBOwwaZRYTsJPioqw7NeESZEVM6rYAqWcZdqvn5jdWn148fl56X6MAqm53KXFNvNtOK062obBR7xy8wqOQXYfr8KApWiUrjKj9WWqwAKEzWJggHpGsrfQXcXDnrNkxPUNLn0EjW+X33M32iCKZeFz30Dn779GOLlL2AipVJAqsAAAMAAAMAIWEAAABwQZokbEM//p4QAABFXbHeAG3nFmt9zprJFuOcnXdfCBrFhxXAZMHHQbAfbNmVM80FVzdKo3ucsPH8fAdnFDNzhQ4HFF0FwDY86Cr5YJMnCAM624bYZP8+A0tPFsyty0CIhvqVizM1qcg29Gmj+W9hYAAAABtBnkJ4hH8AABa5ONUhYzsIIIp758obaxWXh80AAAARAZ5hdEf/AAADAAo4pNfUf4EAAAAYAZ5jakf/AAAjvwQrwTnQdXGdJeoqsDtwAAAALUGaaEmoQWiZTAhn//6eEAAARVH19Yk4lqYIEAcwQmOfarLtJhCf2W8lQT77UAAAACVBnoZFESwj/wAAFrxEQxAA6A4uhj5G4I6UGKnoWyBus/+Bc1ihAAAAHAGepXRH/wAAIqw8W16Z11DDoHXZdpbWlIOZHgwAAAATAZ6nakf/AAAjvwQrwHKL1EdgwQAAADNBmqxJqEFsmUwIZ//+nhAAAEVR9fWJOJbbzRqSSJvqWE1rKsXcyAE+9KoXgYAIb18u9YAAAAAaQZ7KRRUsI/8AABa8Q8+EdNRkP0ZTaIqxFg0AAAAOAZ7pdEf/AAADAAADAakAAAAYAZ7rakf/AAAjvwQrwTnQdXGdJeoqsDtxAAAAJUGa8EmoQWyZTAhn//6eEAAARVH19Yk4lqKQFWWf7ITwPWvTd60AAAAmQZ8ORRUsI/8AABa8PrcI6UfWUqEWfxzsjW6gBVUF9oW1hrTWuLAAAAAcAZ8tdEf/AAAiwz+9+2unoZC3e0eMdjNS0cq24AAAABQBny9qR/8AACO/C6/qKhM3/6zg4QAAACtBmzRJqEFsmUwIZ//+nhAAAEVR9tPYDTPYKFIc2se3qTB7Be7n6iBX6NAnAAAAMkGfUkUVLCP/AAAWtStDMpJstwAJFugOn4ajgzPbo8IOA55AeJE8cTpquRgUq2X5lZJgAAAAGgGfcXRH/wAAI8MXdWiKCgNjC9rcnWDr0ICBAAAAIQGfc2pH/wAAAwC6zHAAlj9g4bLMPShsYVtkpzFNXt/z4QAAAChBm3hJqEFsmUwIZ//+nhAAAEVVDWartpnh4cjdlOLouy1Lnzn9I71hAAAALEGflkUVLCP/AAAWvEnyqAIjZvkrwygI6WsChO8sS4qIeuuxPApLaKp1BT+qAAAAHAGftXRH/wAAIrCr/3v5MgX7Tp9ocSV4T9yGn4MAAAAUAZ+3akf/AAAjx72MGhyifz4HPHEAAAA9QZu8SahBbJlMCGf//p4QAABFVQ1mq7aZ7AxCoAAh38FnXndw82p1la5e/Lk5LOQmxg2H1CluReHhudR3rAAAABpBn9pFFSwj/wAAFrxDz4R01GQ/RlNoirEWDAAAAA4Bn/l0R/8AAAMAAAMBqQAAABgBn/tqR/8AACO/BCvBOdB1cZ0l6iqwO3AAAAAkQZvgSahBbJlMCGf//p4QAABFUfX1iTiWopAVZXVAvalbmB3rAAAAHEGeHkUVLCP/AAAWvEPPhHShaeUoiqvRTLewlYsAAAApAZ49dEf/AAADABpVaOb0AF0AMHDYzFG42XRTyPoyKip8XEH0eogL1xYAAAAUAZ4/akf/AAAjvu1ofYsI6CbjhQUAAABGQZokSahBbJlMCGf//p4QAABFUfYeNgBQDMP0QDClB7gNM9iRxHdayM8Oq4qyWTaGRrZ+EU39y3eN1IrutMpD+Y+KI/W71gAAABpBnkJFFSwj/wAAFrxDz4R01GQ/RlNoirEWDQAAAA4BnmF0R/8AAAMAAAMBqQAAABgBnmNqR/8AACO/BCvBOdB1cZ0l6iqwO3AAAAAqQZpoSahBbJlMCGf//p4QAABFUfX1iTiWopJiAFVliwGiZD4Go9/snL7UAAAAJEGehkUVLCP/AAAWvERDEADoDjRXpfSRXO2oDb/VV9Z/8C5rFQAAAB0BnqV0R/8AACKsPFtT8OHo6ktmJzpxx/Zm4N+24AAAABMBnqdqR/8AACO/BCvAcovUR2DBAAAAPUGarEmoQWyZTAhn//6eEAAARVH19Yk4lrLXZZY6yAUwAsFtWYUn341iRc71XmdMbSHkJWSKi1i/vuECPjwAAAAbQZ7KRRUsI/8AABa8Q8+EdNZZgxhy1WAF/2zBAAAADgGe6XRH/wAAAwAAAwGpAAAAGAGe62pH/wAAI78EK8E52LLhSIVROp37ZwAAACRBmvBJqEFsmUwIZ//+nhAAAEVR9fWJOJajrQFvZeitbala73UAAAAcQZ8ORRUsI/8AABa8Q8+EdKYsNFSBMvg/0Xd8GAAAACkBny10R/8AAAMAGlVovcgAtRMSICEj0HeLYjV/VRmsGB+4aDG3EIpXFgAAABMBny9qR/8AACO/BCvAcovUR2DBAAAAM0GbNEmoQWyZTAhn//6eEAAAAwAHRnzcOABwhMvDvB9D1V+0CPHe7dbhe6wauQXe9gGqGAAAABNBn1JFFSwj/wAAAwACWQAnLQlxAAAAHAGfcXRH/wAAI8hh/MSfcLQghAATKGbgzSQJc+EAAAARAZ9zakf/AAADAAO2/S4NPGEAAAAbQZt4SahBbJlMCGf//p4QAAADAAdAXNJFAGqHAAAAKkGflkUVLCP/AAAWuTOcKmqAIkCSy+1LywQrZMgc2H7r0jDJHO7vingD1wAAABMBn7V0R/8AACPDF3VRUD4VK7BgAAAAFAGft2pH/wAAI77taH2LCOgm44UFAAAAWEGbvEmoQWyZTAhn//6eEAAARU5YEgCfYetsNRQaxYn0DsFuZWXowqM/sbwWjODGfp9C6rXEsd47Or5I53M4DkTKvK+nK03OqSMq04QXk6NDwlAsWkczl0AAAAAbQZ/aRRUsI/8AABa8Q8+EdNZZgxhy1WAF/2zAAAAAGwGf+XRH/wAAI7jB7HptIiOOYAD3Rm4M0kCXPwAAABgBn/tqR/8AACO/BCvBOdiy4UiFUTqd+2YAAAAlQZvgSahBbJlMCGf//p4QAABFUfX1iTiWdps60urwTqoyD2N3PwAAAB1Bnh5FFSwj/wAAFrxDz4R0piw0VlAO0Llfv2v2zQAAACYBnj10R/8AAAMAGnfJgBbgBojhtcbWEmaZbofTfe9JWeIzwcIVigAAABMBnj9qR/8AACO/BCvAcovUR2DBAAAAN0GaJEmoQWyZTAhn//6eEAAARVIlwAvxp2BvrsJRQWP2jTzEKp20TGIRIeYx34DU1KKc5YWgl+QAAAAVQZ5CRRUsI/8AABa8Q8+EK5ObxBHxAAAADgGeYXRH/wAAAwAAAwGpAAAAEwGeY2pH/wAAI78EK8Byi9RHYMAAAAAeQZpoSahBbJlMCGf//p4QAABFUfX1iTg3M2rSUrOAAAAAIEGehkUVLCP/AAAWvERDEADoDi3Su2cEK2JKLZ0N1BHxAAAAHAGepXRH/wAAIqw8VFgK66RJWXqw6QzmroJEriwAAAATAZ6nakf/AAAjx7+M8ByiaX2eOQAAACVBmqxJqEFsmUwIZ//+nhAAAEVR9fWJODczmYzBAAaAatc8EvyAAAAAFUGeykUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bnul0R/8AAAMAAAMBqQAAABMBnutqR/8AACO/BCvAcovUR2DBAAAAHkGa8EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAAB9Bnw5FFSwj/wAAFrxJ8qgCI2b5K8MoCFcuP9hYwPXAAAAAHAGfLXRH/wAAIrCr/2rumal5amVhqfjAE4QEL4AAAAATAZ8vakf/AAAjx72MGhyqpF+FBQAAAB5BmzRJqEFsmUwIZ//+nhAAAEVVDWartomCMEFgl+QAAAAsQZ9SRRUsI/8AABa1K0Myq4gADiyjKwBvNA7H0mPUAlUyK2T14N8gN5iRbcAAAAAaAZ9xdEf/AAAjwxd1aIoKA2ML2tydYOvQgIEAAAAdAZ9zakf/AAADAEWEH/iVm3gxyqgU7VSxRdEWeDEAAAAfQZt4SahBbJlMCGf//p4QAABFTmDIwyNYP22mzN2tmQAAABdBn5ZFFSwj/wAAFrw+twhXKrNfbED1wAAAABoBn7V0R/8AACLDP7V3NABIM3mHUsTKwjzTZgAAABMBn7dqR/8AACO/C6/qKhMx5XYNAAAALEGbvEmoQWyZTAhn//6eEAAARVH24gNAHKNw6NYOSFU7aJgjIDg24HfjCsl4AAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DAAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAAB5Bnh5FFSwj/wAAFrxFITUIVyZ6eFiQAIwqIDVRAj8AAAAaAZ49dEf/AAAiwz+1dzQASDN5h1LEysI802YAAAATAZ4/akf/AAAjvwuv6iokMbp2DQAAACxBmiRJqEFsmUwIZ//+nhAAAEVR9uIDQByjeDAiYbOpKTg3M5a0kuKMX7CX5AAAAB5BnkJFFSwj/wAAFrUrQyb5zIBkxDVvoPh1pKMQrbkAAAAYAZ5hdEf/AAAjwxd1WS/Tt85WcalMiXyTAAAAHQGeY2pH/wAAAwBFhB741YVAMcqoFO1UsUXRFngwAAAAHkGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAAB1BnoZFFSwj/wAAFrw+twhXKrNZGWwAK2whlOiBHwAAACYBnqV0R/8AACLDP7V3NACNlAAg6oPue12WOy7PxMrsWGQfGOYy+AAAABMBnqdqR/8AACO/C6/qKiQxunYNAAAAHkGarEmoQWyZTAhn//6eEAAARVH209gNEwRggsEvyAAAABVBnspFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ7pdEf/AAADAAADAakAAAATAZ7rakf/AAAjvwQrwHKL1EdgwQAAAB5BmvBJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4EAAAAdQZ8ORRUsI/8AABa8PrcIVyqzWRlsACtsIZTogR8AAAAbAZ8tdEf/AAAiwz+1dzPCTOE5qyzlV+ZIToXwAAAAEwGfL2pH/wAAI78Lr+oqJDG6dg0AAAAeQZs0SahBbJlMCGf//p4QAABFUfbT2A0TBGCCwS/IAAAAFUGfUkUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn3F0R/8AAAMAAAMBqQAAABMBn3NqR/8AACO/BCvAcovUR2DBAAAAHkGbeEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAAB1Bn5ZFFSwj/wAAFrw+twhXKrNZGWwAK2whlOiBHwAAABsBn7V0R/8AACLDP7V3M8JM4TmrLOVX5khOhfAAAAATAZ+3akf/AAAjvwuv6iokMbp2DQAAAChBm7xJqEFsmUwIZ//+nhAAAEVR9uIDQByjeC3lwEVUKTg3MtlDW1swAAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DAAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAAB5Bnh5FFSwj/wAAFrxFITUIVyZ6eFiQAIwqIDVRAj8AAAAlAZ49dEf/AAAiwz+1dzPCX9QAIOp5Ze9TXkTU7jIiLIzfDAMvgAAAABMBnj9qR/8AACO/C6/qKiQxunYNAAAAKEGaJEmoQWyZTAhn//6eEAAARVH24gNAHKNw+5F+Iv/07aJgi1j3WS8AAAAfQZ5CRRUsI/8AABa1K0Mm9th17UsvG1NKu7NPJ5d7ZwAAABgBnmF0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAnAZ5jakf/AAADAEWqQgAueruHuba0HutF3L2ib9OpDSUS4xVcFtswAAAAHkGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnoZFFSwj/wAAFrUrQyD60/eBHwAAACsBnqV0R/8AACPDF3VTinsI3AAIfhwhzY3Hqmat8KBYKKcD2XUK70TZBg7cAAAAEwGep2pH/wAAI8e9jBocqqRfhQUAAAAeQZqsSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFUGeykUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bnul0R/8AAAMAAAMBqQAAABMBnutqR/8AACO/BCvAcovUR2DBAAAAHkGa8EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAABRBnw5FFSwj/wAAFrUrQyD60/eBHwAAACQBny10R/8AACPDF3VTinsI3AAId8H7nqbdaXBgFrAr89GsgIAAAAATAZ8vakf/AAAjx72MGhyqpF+FBQAAAB5BmzRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAArQZ9SRRUsI/8AABa1K0Mm9tiO4AAmagEYtbtiwnuEVGQFu0uaiXFIX2PvBgAAABgBn3F0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAnAZ9zakf/AAADAEWqQgAugA0Rw2ubBg8n4Ehov06kNJRLjFVwW2zBAAAAHkGbeEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBn5ZFFSwj/wAAFrUrQyD60/eBHwAAACsBn7V0R/8AACPDF3VTinuGHbhAKxanqgAlTxqhgjE/o0LFPGpgNLatZ2zAAAAAEwGft2pH/wAAI8e9jBocqqRfhQUAAAAeQZu8SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DAAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAAB5Bnh5FFSwj/wAAFrw+twhXKrNZGWwAM+0hUmgEufEAAAApAZ49dEf/AAAiwz+1dzSmTs9Xpt42gAP2tq3XIRqtzanttdnb9brj8GAAAAATAZ4/akf/AAAjvwuv6iokMbp2DQAAAB5BmiRJqEFsmUwIZ//+nhAAAEVR9tPYDRMEYILBL8gAAAAVQZ5CRRUsI/8AABa8Q8+EK5ObxBHxAAAADgGeYXRH/wAAAwAAAwGpAAAAEwGeY2pH/wAAI78EK8Byi9RHYMAAAAAeQZpoSahBbJlMCGf//p4QAABFUfX1iTg3M2rSUrOAAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAJAGepXRH/wAAI8MXdVFOn6TlQAJ1c1VjcuyI21eKmyHVMauwYAAAABMBnqdqR/8AACPHvYwaHKqkX4UFAAAAHkGarEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAACVBnspFFSwj/wAAFrUrQyK5v3KgEAMSSlO0AIEPrGgsPOHmNC2ZAAAAFwGe6XRH/wAAI8MXdVOK8mGnvAQu8S25AAAAGgGe62pH/wAAAwAaXQlZLLZPGjrHrfg54/9nAAAAHkGa8EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBnw5FFSwj/wAAFrUrQyD60/eBHwAAABYBny10R/8AACPC4r77FhHQZciuGeOAAAAAEwGfL2pH/wAAI8e9jBocqqRfhQUAAAAqQZs0SahBbJlMCGf//p4QAABFVQ9mXqwAdA3WrOH+asGOA0TBhMY+UrOAAAAAFUGfUkUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn3F0R/8AAAMAAAMBqQAAABMBn3NqR/8AACO/BCvAcovUR2DBAAAAHkGbeEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAABRBn5ZFFSwj/wAAFrUrQyD60/eBHwAAABsBn7V0R/8AACPC9nRSQAiQBe4qgGwjwInDPHAAAAAWAZ+3akf/AAAjx74wUOA5VLmsEEdgwQAAAClBm7xJqEFsmUwIZ//+nhAAAEVVD2ZerABYJfpOeFD0m+UnBub0J/ylZwAAAB1Bn9pFFSwj/wAAFrU/ZQRFR8at/n5XmGyzLy+wYAAAABcBn/l0R/8AACPDF3VTivJhp7wELvEtuQAAABsBn/tqR/8AACKyMLavVqVvnDyej22fHCpm2YAAAAAeQZvgSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGeHkUVLCP/AAAWtStDIPrT94EfAAAAFAGePXRH/wAAI8LivvsWEdCGOhQQAAAAFAGeP2pH/wAAI8fHFGS/GxaBvBHxAAAAHkGaJEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABxBnkJFFSwj/wAAFrUrQyK5v3KgEAMSYEqGmLbdAAAAFwGeYXRH/wAAI8MXdVOK8mGnvAQu8S25AAAAGgGeY2pH/wAAAwAaXQlZLLZPGjrH3rTcti2YAAAAHkGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnoZFFSwj/wAAFrVaUVMslUHrgQAAABIBnqV0R/8AACPDF3VRUNEkwoIAAAAOAZ6nakf/AAAisjCgAW0AAAAeQZqsSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAKEGeykUVLCP/AAAWtStDIrm/cvwgAC6P/kzHbRhzcHylcwLGLlpawYEAAAAXAZ7pdEf/AAAjwxd1U4ryYae8BC7xLbkAAAAmAZ7rakf/AAADABpdFP6AC1EZmwmTpNVQQ4eQPbf1lgmtVmyxWzEAAAAeQZrwSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGfDkUVLCP/AAAWtStDIPrT94EfAAAAEgGfLXRH/wAAI8MXdVFQ0STCggAAAA4Bny9qR/8AAAMAAAMBqQAAAB5BmzRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAoQZ9SRRUsI/8AABa1K0Miub9TT+gAC+YQExZP6LaHGkd4nSCz1d+/ZgAAABcBn3F0R/8AACPDF3VTivJhp7wELvEtuQAAACcBn3NqR/8AAAMAGl0U/oALUTEiAhk6TLwgI1f1URaUBotUZWbLFbMAAAAeQZt4SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGflkUVLCP/AAAWtStDIPrT94EfAAAAEgGftXRH/wAAI8MXdVFQ0STCggAAAA4Bn7dqR/8AAAMAAAMBqQAAAB5Bm7xJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAdQZ/aRRUsI/8AABa1K0Miub9TNg2qdPGG5+caWzAAAAAXAZ/5dEf/AAAjwxd1U4ryYae8BC7xLbkAAAAmAZ/7akf/AAADABpdFP6AC0Z72N+ZOknqZh/VRFpQGi1RlZssVswAAAAeQZvgSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGeHkUVLCP/AAAWtStDIPrT94EfAAAAEgGePXRH/wAAI8MXdVFQ0STCggAAAA4Bnj9qR/8AAAMAAAMBqQAAAB5BmiRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAmQZ5CRRUsI/8AABa1K0Miub9TSTsAHCAuANVmqVMArmQsXWxwL7MAAAAXAZ5hdEf/AAAjwxd1U4ryYae8BC7xLbkAAAAmAZ5jakf/AAADABpSTyV0AF0AGiNol5c2DB5TYr2VGhbvLFYxK2YAAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAEgGepXRH/wAAI8MXdVFQ0STCggAAAA4BnqdqR/8AAAMAAAMBqQAAAB5BmqxJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAtQZ7KRRUsI/8AABa1K0Miub+t8wAHZDnCZI4WzU/hbkylmTjYKL4LFI9aEoXxAAAAFwGe6XRH/wAAI8MXdVOK8mGnvAQu8S25AAAAGwGe62pH/wAAAwAaUk6uw7BB3nDmYTZHpGLBgQAAAB5BmvBJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAUQZ8ORRUsI/8AABa1K0Mg+tP3gR8AAAASAZ8tdEf/AAAjwxd1UVDRJMKCAAAADgGfL2pH/wAAAwAAAwGpAAAAHkGbNEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAACtBn1JFFSwj/wAAFrUrQyK5v63zAAdgk2sK3JWPgsVp8mcRjkBaiVl3B8uAAAAAFwGfcXRH/wAAI8MXdVOK8mGnvAQu8S25AAAAIwGfc2pH/wAAAwAaUk6uw7BB3nDmYBZ2wATKGbgzSN6LHU+zAAAAHkGbeEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBn5ZFFSwj/wAAFrUrQyD60/eBHwAAABIBn7V0R/8AACPDF3VRUNEkwoIAAAAOAZ+3akf/AAADAAADAakAAAAWQZu5SahBbJlMCP/8hAAAAwAAAwDAgAAAAdpliIQAP//+92ifAptaQ3qA5JXFJdtPgf+rZ3B8j+kDAAADAAADAAAVt6RlhkJ0L/JiAAAFfACyBdhEhIBSxvCr0gp5Akz+CxgAK91BMjLaJEqz+ymb5b1mXOKOTQJjFdSVUcDliSIqQE9n7RFYCltpXySrNI69BVHQhV5Vs6omHyQQLirJPLmE8qRAq6Zw+pDpRzIw4EzYI/hBPzrO5qH99q/6qs6t1/ULDQSHQnPGcmPzpEtvPt1xTtLGZSDCZ3AlWfI8mAuOURCjl0cqsT9FfP5Hjj/7FekMmPaoxadijf3VccBpkBczljkBA/OrNQApyfukPQTvSc4E8WM/1J9HiaGz2qGTw4kkbh5UiH+PTftykUMzCMcUG6ECJRKaaDaThHdfSoFbQpf+x0TF858VPRfE3XUEHqVyzOgeImqbTPTRp+BJxku1e0AAdjWriFOkfXkOZjT5lmi61eTj0URdUqGbliMdL+67LkNUXEFZd3FTY7IdMsS34ZNtWbCpmBEG//nK9cBKkIRrBW7z+/6xvQFwZ9bSAB4azmFjAhCtrDz1WnFVMm6HlBrc8keotmTchh8C//gl3yOYZCjrvbGZRYfqi1wgpmF+BsHLz5RgKEgAAAMAAAMAroAAAACSQZokbEM//p4QAABFXcGRa6wAWClu+DKayuvBqTiWi41s4AAIH/+LjMom0N2npQDkvgA/ajNKOrjCQiVQBJOfOWKpITw4EmE1sRVdt/oWMUbNsT752fa1b52ByHgpSeZXJElJAnBSDH1ay4xm967monagbpGfZzfDSdRP4n7peX3dXs4XIzTjSxhu5ow1mbvO4tkAAAAkQZ5CeIR/AAAWvk21kgBzck6ajJIrnZozRUYMh3WgLMb4kbJAAAAAMwGeYXRH/wAAIqw8W1Pw+swASOuJEA/36ubLsRq/ligGw3PjIk9+SkTWfdoq1JODnwb9UQAAABcBnmNqR/8AACPHv4zwRpCc6QKUF37NwQAAAEhBmmhJqEFomUwIZ//+nhAAAEVVDWartpnzifAjVEPfMg+708sANcclX4l8nxljlqkZslIgus2VufCFwA4JxTDOk8CNIOMhkBgAAAAcQZ6GRREsI/8AABa8Q8+EdNZZeCOcSQCgqyeTDQAAABIBnqV0R/8AAAMACSsPTIo2PIAAAAAYAZ6nakf/AAAjvwQrwTnYsuFIhVE6nftnAAAAJUGarEmoQWyZTAhn//6eEAAARVH19Yk4lqOtAXmfJxU3iDh8dz8AAAAoQZ7KRRUsI/8AABa8QWGhIAX4FJr2G/+4sZ7bf7ahm9Zggy6htYyO3AAAACgBnul0R/8AACKsPFtlYcAFz1dw9ypYlm3cNSqBQi4UnsnWaGLEUbWKAAAAFAGe62pH/wAAI78EK8EZO8iY54vdAAAAOEGa8EmoQWyZTAhn//6eEAAARVH209gNEwZxAoAcYlZcmH1JNhR3fdzEpIRIBWlIPDKxkRqJylZwAAAAFUGfDkUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bny10R/8AAAMAAAMBqQAAABMBny9qR/8AACO/BCvAcovUR2DBAAAAJEGbNEmoQWyZTAhn//6eEAAARVH19Yk4NzNragAQiIxoR5iX5QAAACFBn1JFFSwj/wAAFrxBYaEgBfgUmvYb/7iwl5e9DBn0HrkAAAApAZ9xdEf/AAAirDxbZWHABdABojelk1zB5ORjzDvVV+h8n+TbtGI/bZkAAAATAZ9zakf/AAAjvwQrwHKL1EdgwAAAADJBm3hJqEFsmUwIZ//+nhAAAEVR9tPYDRME8fIAj3GyAMqQikEKGuVnnm/iBBA93MS/IAAAABVBn5ZFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ+1dEf/AAADAAADAakAAAATAZ+3akf/AAAjvwQrwHKL1EdgwAAAAB5Bm7xJqEFsmUwIZ//+nhAAAEVR9fWJODdo3WI6yXkAAAAkQZ/aRRUsI/8AABa8RL8qgCsWfarLBCuTQU2Fyy0VaXySAc+BAAAAGwGf+XRH/wAAIqw8VFSczq5IRv+yjBeVyIA6xQAAABMBn/tqR/8AACPHvYwaHKqt6nYMAAAAHkGb4EmoQWyZTAhn//6eEAAARVH209gNEwRerWsl4AAAABVBnh5FFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ49dEf/AAADAAADAakAAAATAZ4/akf/AAAjvwQrwHKL1EdgwAAAAB5BmiRJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4EAAAAZQZ5CRRUsI/8AABa8RSE1CFclLZK4NCXPgAAAABsBnmF0R/8AACLGq4zPyY/IpeyftNJcI6Oe1ikAAAATAZ5jakf/AAAjvwxK5ocomlKdgwAAAClBmmhJqEFsmUwIZ//+nhAAAEVR9vPtoAXwVr4ktVn+dJ20TBFnHasl4AAAABVBnoZFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ6ldEf/AAADAAADAakAAAATAZ6nakf/AAAjvwQrwHKL1EdgwQAAAB5BmqxJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4EAAAAjQZ7KRRUsI/8AABa8SfKoAbkzznzo+0kH2eorsYsR4G8QDnwAAAAbAZ7pdEf/AAAiwz+1dzQASDN5h1EtQ1WqFcWAAAAAEwGe62pH/wAAI8e9jBocqqRfhQUAAAAmQZrwSahBbJlMCGf//p4QAABFVQ03EqQBvOoDRMEc7cOeM9kClZwAAAAVQZ8ORRUsI/8AABa8Q8+EK5ObxBHxAAAADgGfLXRH/wAAAwAAAwGpAAAAEwGfL2pH/wAAI78EK8Byi9RHYMEAAAAeQZs0SahBbJlMCGf//p4QAABFUfX1iTg3M2rSUrOBAAAAHkGfUkUVLCP/AAAWvEUhNQhXJnp4WJAAjCogNVECPwAAACQBn3F0R/8AACLDP7V3NACNlAAg8GTo1dljdRJA1usMg+Mcxl8AAAATAZ9zakf/AAAjvwuv6ioTMeV2DAAAAClBm3hJqEFsmUwIZ//+nhAAAEVR9vPtoARxX/KDm/MtOprB+0aH21KzgAAAAB5Bn5ZFFSwj/wAAFrUrQyb5zIBkxDVvoPh1pKMQrbkAAAAYAZ+1dEf/AAAjwxd1WS/Tt85WcalMiXyTAAAAHQGft2pH/wAAAwBFhCBN1aLgMcqoFO1UsUXRFngwAAAAHkGbvEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBn9pFFSwj/wAAFrUrQyD60/eBHwAAACcBn/l0R/8AACPC4r77FjEAs5BpQAEHgydF+tCvSI/VPZ+xdoqDrbkAAAATAZ/7akf/AAAjx72MGhyqpF+FBAAAAB5Bm+BJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAeQZ4eRRUsI/8AABa1K0Mm+cyAZMQ1b6D4daSjEK25AAAAGAGePXRH/wAAI8MXdVkv07fOVnGpTIl8kwAAAB0Bnj9qR/8AAAMARYQgTdWi4DHKqBTtVLFF0RZ4MAAAAB5BmiRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAUQZ5CRRUsI/8AABa1K0Mg+tP3gR8AAAAlAZ5hdEf/AAAjwuK++xYxALHUqn8mkONN6ABLHZmaGa9S6nVtmQAAABMBnmNqR/8AACPHvYwaHKqkX4UFAAAAHkGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABVBnoZFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ6ldEf/AAADAAADAakAAAATAZ6nakf/AAAjvwQrwHKL1EdgwQAAAB5BmqxJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4EAAAAUQZ7KRRUsI/8AABa1K0Mg+tP3gR8AAAAbAZ7pdEf/AAAjwxd1U4p6uQmvehEYAgT9mFeDAAAAEwGe62pH/wAAI8e9jBocqqRfhQUAAAAeQZrwSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFUGfDkUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bny10R/8AAAMAAAMBqQAAABMBny9qR/8AACO/BCvAcovUR2DBAAAAHkGbNEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAABRBn1JFFSwj/wAAFrUrQyD60/eBHwAAACgBn3F0R/8AACPC4r77FjEAsdWCgAEHgydFQp/5pRW6EmQ8Zj6YMpW3AAAAEwGfc2pH/wAAI8e9jBocqqRfhQQAAAAeQZt4SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAALkGflkUVLCP/AAAWtStDJvbYmcQAF0BKY5EXi+shEAYOS42NfcPj0wB62BortmEAAAAYAZ+1dEf/AAAjwxd1WS/Tt85WcalMiXyTAAAAHgGft2pH/wAAAwBFhCL1JGqVXm563T1t/k8x/T/BgAAAAB5Bm7xJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAUQZ/aRRUsI/8AABa1K0Mg+tP3gR8AAAArAZ/5dEf/AAAjwxd1U4p7CNwACH3NVYhJVSfs2Bw0N2E31EH7ciBFouo7cQAAABUBn/tqR/8AACPHs25wHK8ozuYcdgwAAAAeQZvgSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAL0GeHkUVLCP/AAAWtUzCQAWszmFUFL7xtpNFENEiIIp4+xHSUz5IZtZlrM483PbNAAAAGAGePXRH/wAAI8MXdVkv07fOVnGpTIl8kwAAABwBnj9qR/8AACKyMNswMwyjqTdbQAwmFwdijPtuAAAAHkGaJEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBnkJFFSwj/wAAFrUrQyD60/eBHwAAACkBnmF0R/8AACPDF3VTinuGHbg/6+xAAHvuCAQ2qLxClwxfiH7o6TmLbwAAABUBnmNqR/8AACPHs25wHK8ozuYcdg0AAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAJkGehkUVLCP/AAAWtUzCQAWszmFUFL7xoQfwFn6hA/7pWcnbH/BhAAAAGAGepXRH/wAAI8MXdVkv07fOVnGpTIl8kwAAACgBnqdqR/8AACKyMNswM9ZgAkdWZsHuFH7BfxXJO+Wu4yM/hvBe7k7dAAAAHkGarEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBnspFFSwj/wAAFrUrQyD60/eBHwAAACkBnul0R/8AACPDF3VTinuGHbg/xLMqgAnUqFo8wMUMGc3fr6VhOiXXgwAAABUBnutqR/8AACPHs25wHK8ozuYcdg0AAAAeQZrwSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFUGfDkUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bny10R/8AAAMAAAMBqQAAABMBny9qR/8AACO/BCvAcovUR2DBAAAAHkGbNEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgQAAABRBn1JFFSwj/wAAFrUrQyD60/eBHwAAACMBn3F0R/8AACPDF3VRTp+k5UAC6BUCwc3hosGW4ZdKC6zxwQAAABUBn3NqR/8AACPHs25wHK8ozuYcdgwAAAAzQZt4SahBbJlMCGf//p4QAABFVcB5AJqxBZXPtwnFCA/lJzQLPz3Ip1lScG7GXNwzDa2YAAAALkGflkUVLCP/AAAWvqKtwpfH4dwABM1JlH4ePZmfyjwfamPvucurbeknJZubXFkAAAAYAZ+1dEf/AAAjwxd1WS/Tt85WcalMiXyTAAAAKAGft2pH/wAAI78b6iuiAAueruHuVLEs27gyjVv+VdD00r/Kvgwu1swAAAAeQZu8SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGf2kUVLCP/AAAWtStDIPrT94EfAAAAEwGf+XRH/wAAI7CjEYLCPBG5OwcAAAAWAZ/7akf/AAAjucGtNTYDlePJD7whQQAAAC5Bm+BJqEFsmUwIZ//+nhAAAEVOWBIAn2HrbE951q7PI43yI///KTg3N6HCNSs4AAAAKkGeHkUVLCP/AAAWtStDJwJu4ATSfkijFzCrDf+FOjR/g/PZrRdUjHFtmQAAABgBnj10R/8AACPDF3VZL9O3zlZxqUyJfJMAAAApAZ4/akf/AAADAEU5SvcgAtRMSICDYq9eEBGr+fSwZrDUMarTC7j1eDAAAAAeQZokSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFEGeQkUVLCP/AAAWtStDIPrT94EfAAAAEgGeYXRH/wAAI8MXdVFQ0STCgwAAAA4BnmNqR/8AAAMAAAMBqQAAAB5BmmhJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAsQZ6GRRUsI/8AABa1K0MnAm7gBNMJKkaU9Z5ol1ZIU6NH+D89mtF1SMcW2YEAAAAYAZ6ldEf/AAAjwxd1WS/Tt85WcalMiXyTAAAAJwGep2pH/wAAAwBFqkIALnq7h7m2tB7rRdy9om/TqQ0lEuMVXBbbMQAAAB5BmqxJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAUQZ7KRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ7pdEf/AAAjwxd1UVDRJMKCAAAADgGe62pH/wAAAwAAAwGpAAAAHkGa8EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAAB9Bnw5FFSwj/wAAFrUcghMWM+aRm/oxipCmXts1ktmBAAAAFwGfLXRH/wAAI8MXdVOK8mGnvAQu8S24AAAAKQGfL2pH/wAAIrIw25OmACWP2DhsvIDctFPXbkKwxlaCBa+UtLsLHbZhAAAAHkGbNEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBn1JFFSwj/wAAFrUrQyD60/eBHwAAABIBn3F0R/8AACPDF3VRUNEkwoMAAAAOAZ9zakf/AAADAAADAakAAAAeQZt4SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAH0GflkUVLCP/AAAWtRyCExYz5pGb+jGKkKZe2zWS2YEAAAAXAZ+1dEf/AAAjwxd1U4ryYae8BC7xLbgAAAAnAZ+3akf/AAAisjDbk6YAJY/NEb0smuYPJKA58CF7bFr5S0uwsdtmAAAAJUGbvEmoQWyZTAhn//6eEAAARVUNZqu2iYMsmgCKqI8Wum67WzEAAAAUQZ/aRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ/5dEf/AAAjwxd1UVDRJMKDAAAADgGf+2pH/wAAAwAAAwGpAAAAOEGb4EmoQWyZTAhn//6eEAAARVUOfR2ACwUqQONuHD047aJgwm+ixYXkqLycm64dOa3HANvhaEvyAAAAKUGeHkUVLCP/AAAWtT9lBEVHxrPCAALo/+TMXtGGpiJx3Rfx5TdyTq2ZAAAAFwGePXRH/wAAI8MXdVOK8mGnvAQu8S24AAAAKAGeP2pH/wAAIr8b6quiAAugA0RvSya5g8kmYZWZWYjppYX6WU5XrZgAAAA7QZokSahBbJlMCGf//p4QAABDUgaeyT9aowAGPoEFbnTwU1EEUp+We81SjYOOja7Kppq9ehQnSuJZzzEAAAAfQZ5CRRUsI/8AABa+o54gu2gTZTwcUqBA62HidakduAAAABQBnmF0R/8AACPDA6BocqcJHj6FBQAAABoBnmNqR/8AACO/BCvIToP5H8i2uwFMkez1swAAACdBmmhJqEFsmUwIZ//+nhAAAENVFU9kqTK0gejT/HmMNPSXuBwJZl8AAAAoQZ6GRRUsI/8AABYsTulKw5W9A0RPYAA4QGfvPj7FPAp4q+EysGDO3QAAABgBnqV0R/8AAAMAupGYOdviw0Wns4puRWkAAAAbAZ6nakf/AAAiuc6B5ijv6mU1MA8ohWwGXW3BAAAANkGarEmoQWyZTAhn//6eEAAARU5gvY7QAcYzBzAOadtExc8+od94slsccGJdM/rTXWvtb1trZwAAABRBnspFFSwj/wAAFrUrQyD60/eBHwAAACEBnul0R/8AACPDIJ/iwAjABdpi2NhHfON5y+sbU4RvCggAAAAOAZ7rakf/AAADAAADAakAAAA5QZrwSahBbJlMCGf//p4QAABFVQ9mYRsAKASvtQooGu381QGiYMK8V1s6QnlXkd//L4vePocKMS/IAAAAH0GfDkUVLCP/AAAWtUAiUoR0lehohoOx7G+d+yaN9mEAAAAXAZ8tdEf/AAAjwxd1U4ryYae8BC7xLbgAAAAnAZ8vakf/AAAisjC2r2VrgAtGe9jfiHxN7GABlj/SG0225H8BGaSZAAAAKEGbNEmoQWyZTAhn//6eEAAARU5gyMMjWD9t4eAIF929tSCKKkwJfkEAAAAUQZ9SRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ9xdEf/AAAjwxd1UVDRJMKDAAAADgGfc2pH/wAAAwAAAwGpAAAAHkGbeEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABVBn5ZFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ+1dEf/AAADAAADAakAAAATAZ+3akf/AAAjvwQrwHKL1EdgwAAAAD5Bm7xJqEFsmUwIZ//+nhAAAAMAhyz8DgADn/w7uCpvnf6vZFSKzew8SC/TlVRnXb2Mx7rU7Gh3UDhd5e1PgQAAAB9Bn9pFFSwj/wAAFsCbP8uyyvKqlHFKgQOtkM3LKtuBAAAAEgGf+XRH/wAAI8MXdVFQ0STCgwAAABoBn/tqR/8AACO/BCvIToP5H8i2uwFMkez1swAAACdBm+BJqEFsmUwIZ//+nhAAAAMAhqPr6uF71XeIlmr87oMsHTf3RYAAAAAvQZ4eRRUsI/8AABYd/cfdpUqKRs34NCpkDAAc4EtEMDXKzQ8qhOwZwwPdRv2ZG2cAAAAYAZ49dEf/AAAiwz/VSWjCO7/HWAHZwlHdAAAAGwGeP2pH/wAAIrIwtqVkzHmpJJmVo3RlTC0tuAAAAD1BmiRJqEFsmUwIZ//+nhAAAEVOYMSkfsAEO+/74r4eSAhuA0TFvofhoGK9roi4tUl0dIS168rYCTQcobWzAAAAFEGeQkUVLCP/AAAWtStDIPrT94EfAAAAEgGeYXRH/wAAI8MXdVFQ0STCgwAAAA4BnmNqR/8AAAMAAAMBqQAAAB5BmmhJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAVQZ6GRRUsI/8AABa8Q8+EK5ObxBHxAAAADgGepXRH/wAAAwAAAwGpAAAAEwGep2pH/wAAI78EK8Byi9RHYMEAAAAeQZqsSahBbJlMCGf//p4QAABFUfX1iTg3M2rSUrOBAAAAFEGeykUVLCP/AAAWtStDIPrT94EfAAAAEgGe6XRH/wAAI8MXdVFQ0STCggAAAA4BnutqR/8AAAMAAAMBqQAAAB5BmvBJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAwQZ8ORRUsI/8AABa1K0MiucAgca8mvuKHwAGqk2MW8UDjdm4FBl5vIVCaZ5MoZCO3AAAAFwGfLXRH/wAAI8MXdVOLIXcqwftuUjeDAAAALwGfL2pH/wAAAwAaUk70CAC1ExIgINir14QEav6qLAwbS16LVvv6th3t7DlA1fqhAAAAHkGbNEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABRBn1JFFSwj/wAAFrUrQyD60/eBHwAAABIBn3F0R/8AACPDF3VRUNEkwoMAAAAOAZ9zakf/AAADAAADAakAAAAxQZt4SahBbJlMCGf//p4QAABFVQ8epoArVLeG0wYnbRMGGLIleLIdrozoTmPhM621swAAACpBn5ZFFSwj/wAAFrU/ZQQZrplnEABOsI0zdyp/ONapBPQTJxzRjvLAj4EAAAASAZ+1dEf/AAAjwxd1UVDRJMKCAAAALAGft2pH/wAAIrnOgeX3a9p4AWQmJEA/byXbLsRq/livOBRcnbzgE80ySEBAAAAAQEGbvEmoQWyZTAhn//6eEAAAQ1IGnslFNoAFRrC2YhYgzOjevDUP3afAUWrrT8QpYJ4Mz/TQJeGokVDGgSP8kI8AAAAfQZ/aRRUsI/8AABa+o54gu2gTZTwcUqBA62HidakduQAAABQBn/l0R/8AACPDA6BocqghhxCggQAAABoBn/tqR/8AACO/BCvIToP5H8i2uwFMkez1swAAAChBm+BJqEFsmUwIZ//+nhAAAEOeqG2fZ59IEoULgrzo7OgmfblQODL4AAAAIUGeHkUVLCP/AAAWLE7pSsOVvQH15lRmXbUAJRzSG/gtmQAAAB0Bnj10R/8AACK6U6CJYCbc6FaqsnbTQaT4MitCAgAAACoBnj9qR/8AACK/G971xOAOAC1ExIgH6ZEu5bEav5ZKIkyntDNcpw9pJMAAAAA+QZokSahBbJlMCGf//p4QAABFTmC9jtACO12rTAD9nbRMXPPqHfeOQgYUdaozTunjsaOBEVQWSy5ZaY5lSs8AAAAUQZ5CRRUsI/8AABa1K0Mg+tP3gR8AAAAdAZ5hdEf/AAAjwyCY80OU4XejGAAB4h9lnuy27BkAAAAOAZ5jakf/AAADAAADAakAAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAIEGehkUVLCP/AAAWtTLlmsJgmfm+dxACtnglZGvB5c+BAAAAEgGepXRH/wAAI8MXdVFQ0STCggAAACoBnqdqR/8AACK/G98CdMAEsfsHDZeQG5aKevCnVIL6pIVg6a665AIJjkkAAABGQZqsSahBbJlMCGf//p4QAABDUnNYAUAzF0MV2nK/nm0/FDuQ8iTPzDMLDy09N1G04WFUkGvQGRzzjrbBWEySeQp3AXJ8cQAAAB9BnspFFSwj/wAAFr6jniC7aBNlPBxSoEDrYeJ1qR24AAAAFAGe6XRH/wAAI8MDoGhyqCGHEKCAAAAAGgGe62pH/wAAI78EK8hOg/kfyLa7AUyR7PWzAAAALUGa8EmoQWyZTAhn//6eEAAARVH19Yk79pas0lrqUtZLJ94oAjfR07VQmrsswAAAACBBnw5FFSwj/wAAFrxDz4cpkqh69TGoUMEwBw+SalNswQAAABsBny10R/8AAAMARZA4AiPVccyzE7sVgbmJR24AAAAZAZ8vakf/AAAjvwQrwTpBSH2H9eNeKUH4MQAAABdBmzRJqEFsmUwIZ//+nhAAAAMAAAMDPwAAABBBn1JFFSwj/wAAAwAAAwEHAAAAJAGfcXRH/wAAI8hhpjn0AEYAG4QraHIfXgwCYv3NR0ayaLeFBQAAAA4Bn3NqR/8AAAMAAAMBqQAAADtBm3hJqEFsmUwIZ//+nhAAAEVOWBIA3WjbTVmZLS4TY3WfakpODdmub3C8jAC0SJvf/OG62OLy6G2tmAAAACFBn5ZFFSwj/wAAFrUy5ZrCYJn5vncQAraV3VJ4q8Hlz4EAAAASAZ+1dEf/AAAjwxd1UVDRJMKCAAAAGwGft2pH/wAAIr8b2rniLmGNcvA5aJzjYMB/LgAAABlBm7lJqEFsmUwI//yEAAAPgM4HBLSdcCHhAAABlWWIggAP//73aJ8Cm1pDeoDklcUl20+B/6tncHyP6QMAAAMAAAMAABW3pGWGQnQv8mIAAAV8ALIF2ESEgFLG8KvSQuZmJ+CxgAEqMq9lujCie47hpX3fTd8aV31j/paq1WRMVTXlvgAADPbhIJKd1zC0fntssNdQ6nRbl2PZjDD4qzxWZsYza39ggr8aa06Vo/n0SJsAse4x7O4zEQDwMAQVnDVL6ucuEpzfrMD9ubb7q7J8JGcXWmqCLBmiU1AI0EAOUV15ggNQXAbhdbGVlGksox20L20VUdJ5isrVRfq4Uv5RdRYR2Bp94dyTbzWzi9D8IvIRsya/Y2d/ALkNl77EgEh8UM44fiF5t0gnBkC51Y/CZuSsYPIJiV1683nPaBXr4Dwd5TfOA87xv1ZZ/5ojbz0v0YBVNzuUuKbZmKalKyTKUV3gJAndcQxFphFXM7xCuDzbmWNAi728d4ID7E/FThQYWf/2TIt9Nz6enxhoJGiQp8Pdnkglf4vXi4aNJowH+IOgl5xZstAHMAAAAwAAAwADiwAAAG1BmiRsQz/+nhAAAEVdsd4AbecWa33OmskW45ydd18IGsWIwsmAAA9f/2TZpI2kVp/tiTTfqoVKhYZ3NlYVYjgxbQvMUaeC2mImhHtMkjQhXgQt1bNA88Dko2IbvJIBclbZb5UAB9gBmHFhKkvBAAAAF0GeQniEfwAAFrk41SFjPZXqhTCNotTAAAAAEwGeYXRH/wAAAwAKOKSwqPJ6r4AAAAATAZ5jakf/AAAjvwQrwHKL1EdgwQAAAB5BmmhJqEFomUwIZ//+nhAAAEVR9fWJODdcwHSVKzgAAAAeQZ6GRREsI/8AABa8RSE1CFcmenhYkACMKiA1UQI+AAAAJgGepXRH/wAAIsM/tXczwmeVABCZT4aqWz+HeTEuSuEJQk/MOQPnAAAAGwGep2pH/wAAI77+lFJACJAF7iqAbCO73VhnjgAAAC5BmqxJqEFsmUwIZ//+nhAAAEVR9uIDQByjd7x7im5P/yk4N2i7l3gVrfLu7a2ZAAAAL0GeykUVLCP/AAAWtStDJvnRRwAC1Ipby4jw1HD853Ne7lhrlTx34ExtjCduM+2ZAAAAGAGe6XRH/wAAI8MXdVkv07fOVnGpTIl8kwAAABwBnutqR/8AAAMARTlKIYBOON396QZFpIO7AyndAAAAHkGa8EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnw5FFSwj/wAAFrUrQyD60/eBHwAAACcBny10R/8AACPDF3VTinq5H3gACHzhwAXjdIC+R/Cxhm9HeswHbMEAAAATAZ8vakf/AAAjx72MGhyqpF+FBAAAAChBmzRJqEFsmUwIZ//+nhAAAEVVDW5poA5Ru9e9gUk5Z20TBjwjy2tmAAAAFUGfUkUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bn3F0R/8AAAMAAAMBqQAAABMBn3NqR/8AACO/BCvAcovUR2DBAAAAHkGbeEmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAAB5Bn5ZFFSwj/wAAFrxFITUIVyZ6eFiQAIwqIDVRAj8AAAAbAZ+1dEf/AAAiwz+1dzPCTODfNgAFFHmF4hfBAAAAEwGft2pH/wAAI78Lr+oqEzHldg0AAAAeQZu8SahBbJlMCGf//p4QAABFUfbT2A0TBGCCwS/JAAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DBAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnh5FFSwj/wAAFrUrQyD60/eBHwAAACYBnj10R/8AACPDF3VTinq5GjUAEHgydFPbiXUROZvpuEO9ZgO2YQAAABMBnj9qR/8AACPHvYwaHKqkX4UFAAAAKUGaJEmoQWyZTAhn//6eEAAARVUNbmmgDlG72YW/shxE7aJgx4R5bWzBAAAAH0GeQkUVLCP/AAAWtStDJvbYde1LLxtSKrgxKEXGe2YAAAAYAZ5hdEf/AAAjwz+9pdfTLLCAKuzec1twAAAAKQGeY2pH/wAAAwBFOUr3IALUTEiAg2KvXhARq/n0sGaw1DGq0wu49XgxAAAAHkGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnoZFFSwj/wAAFrUrQyD60/eBHwAAACkBnqV0R/8AACPDF3VTinq4wzcAEBU8qoetbbHRDEnscqNam6OytybZgQAAABMBnqdqR/8AACPHvYwaHKqkX4UEAAAAHkGarEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAABVBnspFFSwj/wAAFrxDz4Qrk5vEEfEAAAAOAZ7pdEf/AAADAAADAakAAAATAZ7rakf/AAAjvwQrwHKL1EdgwQAAAB5BmvBJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4AAAAAUQZ8ORRUsI/8AABa1K0Mg+tP3gR8AAAApAZ8tdEf/AAAjwxd1U4p7CNwACH4Z+513Pz5SGfNGATGWGZECLRdR24EAAAATAZ8vakf/AAAjx72MGhyqpF+FBAAAAB5BmzRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAArQZ9SRRUsI/8AABa1K0Mm9tiO4AAmagEYtbtiwnuEVGQFu0pwo/3VvtE9swAAABgBn3F0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAoAZ9zakf/AAADAEWqQgAugBg4bREA3LRTyMAJDRfp1IaSiXGKrgttmQAAAB5Bm3hJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAAtAZ+1dEf/AAAjwuK++xYxALxKOxV6oixABMw1VmCJF84xfxrQ/C/jF+YYvnbhAAAAEwGft2pH/wAAI8e9jBocqqRfhQUAAAAeQZu8SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DBAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnh5FFSwj/wAAFrUrQyD60/eBHwAAACkBnj10R/8AACPDF3VTinuGHbg/xLMqgAnUqFmt759GZzeLHh+D5rEltwAAABMBnj9qR/8AACPHvYwaHKqkX4UFAAAAHkGaJEmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8wAAACtBnkJFFSwj/wAAFrUrQycCbuAE0wkqRpT1nmiXVWKGjR/g/PZrRdUjHFtmAAAAGAGeYXRH/wAAI8MXdVkv07fOVnGpTIl8kwAAABoBnmNqR/8AAAMAGl0JWSy2Txo6x9603LYtmQAAAB5BmmhJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ6GRRUsI/8AABa1K0Mg+tP3gR8AAAAkAZ6ldEf/AAAjwuK++xYRwwAyyABdApDUZgOxDI15LjK39ODhAAAAEwGep2pH/wAAI8e9jBocqqRfhQQAAAAeQZqsSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFUGeykUVLCP/AAAWvEPPhCuTm8QR8QAAAA4Bnul0R/8AAAMAAAMBqQAAABMBnutqR/8AACO/BCvAcovUR2DBAAAAHkGa8EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnw5FFSwj/wAAFrUrQyD60/eBHwAAABUBny10R/8AACPC4r77FhHQZcnPc8cAAAATAZ8vakf/AAAjx72MGhyqpF+FBAAAAB5BmzRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAcQZ9SRRUsI/8AABa1K0Miub9yoBADEmBKhpi23QAAABcBn3F0R/8AACPDF3VTivJhp7wELvEtuAAAACYBn3NqR/8AAAMAGl0U/oALURmbCZOk1VBDh5A9t/WWCa1WbLFbMQAAAB5Bm3hJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ+1dEf/AAAjwxd1UVDRJMKDAAAAEwGft2pH/wAAI8e9jBocqqRfhQUAAAAoQZu8SahBbJlMCGf//p4QAABFVQ1uaaAOUbvXohUs+5ScG5wJXj7WzQAAABVBn9pFFSwj/wAAFrxDz4Qrk5vEEfAAAAAOAZ/5dEf/AAADAAADAakAAAATAZ/7akf/AAAjvwQrwHKL1EdgwQAAAB5Bm+BJqEFsmUwIZ//+nhAAAEVR9fWJODczatJSs4AAAAAUQZ4eRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ49dEf/AAAjwxd1UVDRJMKDAAAAFQGeP2pH/wAAI8e+MFDgOVUCqT2hQQAAACdBmiRJqEFsmUwIZ//+nhAAAEVVDW5poArVKd1rn8NO2iYMeEeW1s0AAAAmQZ5CRRUsI/8AABa1K0Miub9y/CAALo/+TMdtGGpiQIKijFy0tYMAAAAXAZ5hdEf/AAAjwxd1U4ryYae8BC7xLbgAAAAmAZ5jakf/AAADABpdFP6AC1EZmwmTpMw+/rNu2OtAaLVGVmyxWzEAAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAEgGepXRH/wAAI8MXdVFQ0STCgwAAABQBnqdqR/8AACPHxxRkv0x0AgBHwAAAAB5BmqxJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAnQZ7KRRUsI/8AABa1K0Miub9y/CAALoegKFuXzNSqXJUIbwRbv5+zAAAAFwGe6XRH/wAAI8MXdVOK8mGnvAQu8S24AAAAJwGe62pH/wAAAwAaXRT+gAtRMSICGTpMvCAjV/VRFpQGi1RlZssVswAAAB5BmvBJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ8ORRUsI/8AABa1K0Mg+tP3gR8AAAAUAZ8tdEf/AAAjwuK++xYR0IY6FBEAAAAUAZ8vakf/AAAjx8cUZL9MdAIAR8AAAAAeQZs0SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAKEGfUkUVLCP/AAAWtStDIrm/U0/oAAvmEBMWT+i2hxoqHKkxEvrGW28AAAAXAZ9xdEf/AAAjwxd1U4ryYae8BC7xLbgAAAAoAZ9zakf/AAADABpSTyV0AF0AMHDYjQJneDynkfRXsqNC3eWKxiVswQAAAB5Bm3hJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/IAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAAUAZ+1dEf/AAAjwuK++xYR0IY6FBEAAAAUAZ+3akf/AAAjx8cUZL9MdAIAR8EAAAAeQZu8SahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAFUGf2kUVLCP/AAAWvEPPhCuTm8QR8AAAAA4Bn/l0R/8AAAMAAAMBqQAAABMBn/tqR/8AACO/BCvAcovUR2DBAAAAHkGb4EmoQWyZTAhn//6eEAAARVH19Yk4NzNq0lKzgAAAABRBnh5FFSwj/wAAFrUrQyD60/eBHwAAABIBnj10R/8AACPDF3VRUNEkwoMAAAAUAZ4/akf/AAAjx8cUZL9MdAIAR8EAAAAeQZokSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAJ0GeQkUVLCP/AAAWtStDIrm/U0k7ABwkbyZb9UxqYXXkmBHQTGu24AAAABcBnmF0R/8AACPDF3VTivJhp7wELvEtuAAAABsBnmNqR/8AAAMAGlJOrsOwQd5w5mE2R6RiwYEAAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAEgGepXRH/wAAI8MXdVFQ0STCgwAAAA4BnqdqR/8AAAMAAAMBqQAAADJBmqxJqEFsmUwIZ//+nhAAAEVVDx6mgCJDcO5qYz4nbRMGFTOAZIyc09Xy227h/W2tmQAAACtBnspFFSwj/wAAFrUy5ZrGet6KeKAALoegKFu/FFM20qkQXEjIW+FQxn7NAAAAFwGe6XRH/wAAI8MXdVOK8mGnvAQu8S24AAAAJwGe62pH/wAAIr8b3vXE6tcAF0AGiNVcr02DB5OT/M/LfewUOoO8kwAAAENBmvBJqEFsmUwIZ//+nhAAAENSc1gA6BvBYmakH77/Fn2/e7WsQRaSW9zmAhcpl3apXqaSqeqJl4QaL16JrA7ns06gAAAAH0GfDkUVLCP/AAAWvqOeILtoE2U8HFKgQOth4nWpHbkAAAAUAZ8tdEf/AAAjwwOgaHKoIYcQoIEAAAAaAZ8vakf/AAAjvwQryE6D+R/ItrsBTJHs9bMAAAAzQZs0SahBbJlMCGf//p4QAABDVRVPZKkytIHo0/yVrRAHKABtIVoT5Tf7SQV0vxgBQHzAAAAAKkGfUkUVLCP/AAAWLE7pSsOVvQM/NmAA7IcVcJ/fjJbAro6nXizXn8WduQAAABcBn3F0R/8AAAMARZAp7IirXBudvtFM+AAAACgBn3NqR/8AACK5zoHl7W36gAtwA0RpEh4mwYPJyf7ITXOD8EosJ8GBAAAAOkGbeEmoQWyZTAhn//6eEAAARU5gvY7QAcYzDo1kA/rO2iYuejfMhdq9PpxlFfNy/vb3a0vPLeKsl4AAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAAhAZ+1dEf/AAAjwvZ0UkAIkAXuKoBsI8BLkejqRuRz28KDAAAADgGft2pH/wAAAwAAAwGpAAAAO0GbvEmoQWyZTAhn//6eEAAARVUPZl6sAHQKWWYTlA13AZScG5vWejW0f0uWzTacYf/xWqn7rdXhIpWdAAAAL0Gf2kUVLCP/AAAWtUAiUoR0lf45xFqbgX4ADVIllgwSrRDuGryUxtvSKt5G9O24AAAAFwGf+XRH/wAAI8MXdVOLIXcqwftuUjeDAAAAHAGf+2pH/wAAIrIwtqVkzHmpJJmVoxEEDJQ/bcEAAAAeQZvgSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGeHkUVLCP/AAAWtStDIPrT94EfAAAAEgGePXRH/wAAI8MXdVFQ0STCgwAAAA4Bnj9qR/8AAAMAAAMBqQAAAB5BmiRJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAArQZ5CRRUsI/8AABa1K0MiucAgca8mwQCCABD5+jOxRfTTjz+FrqRzgqWO3AAAABcBnmF0R/8AACPDF3VTiyF3KsH7blI3gwAAACgBnmNqR/8AAAMAGnfJgBbgDBw2iIBuWinkfPwcQ7cbozhEa75uqrFBAAAAJEGaaEmoQWyZTAhn//6eEAAARVUNZqu2iYMqdAE3UR+WClKzgAAAABRBnoZFFSwj/wAAFrUrQyD60/eBHwAAABIBnqV0R/8AACPDF3VRUNEkwoMAAAAOAZ6nakf/AAADAAADAakAAAAeQZqsSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvzAAAAJEGeykUVLCP/AAAWvEPPhCtVbDngAE7H3ZMWjpgP0MacI9LnwQAAABEBnul0R/8AAAMAA7dfH+qygAAAABMBnutqR/8AACO/BCvAcr0UqOwZAAAAJ0Ga8EmoQWyZTAhn//6eEAAAAwAzbG1B4DBEX87Wnd3vWOsWNUnlfgAAAB5Bnw5FFSwj/wAAFsCbP8tCMuTkgb29nLMQJvrr9mEAAAASAZ8tdEf/AAAjwxd1UVDRJMKDAAAAGQGfL2pH/wAAI78EK8Ms0oJ2ngrYD2LzeSYAAAAlQZs0SahBbJlMCGf//p4QAAADADN0nqqwU3cwZT5EqdScR6CaswAAACJBn1JFFSwj/wAAAwAQV/Xbi6i6VV3fAAQF47eTMdHgz9mBAAAAGwGfcXRH/wAAAwBFK/laIJQbVDQcaaT9CpB8GAAAABcBn3NqR/8AAAMACkEBQLTDmeZfM3D/FwAAAEBBm3hJqEFsmUwIZ//+nhAAAEVOYLkx+wAQ78PtqKadq73CAyTXx20TFzxwHobpF3i9WR6II7MngzL/o7s8VZLwAAAAFEGflkUVLCP/AAAWtStDIPrT94EfAAAAEgGftXRH/wAAI8MXdVFQ0STCgwAAAA4Bn7dqR/8AAAMAAAMBqQAAAB5Bm7xJqEFsmUwIZ//+nhAAAEVVDWartomDH5/wS/MAAAAUQZ/aRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ/5dEf/AAAjwxd1UVDRJMKCAAAAIAGf+2pH/wAAAwAKOUdzrZ2DQAQb43vrk8eZCdhSWKerAAAAHkGb4EmoQWyZTAhn//6eEAAARVUNZqu2iYMfn/BL8gAAABRBnh5FFSwj/wAAFrVaUVMslUHrgAAAABIBnj10R/8AACPDF3VRUNEkwoMAAAAOAZ4/akf/AAAisjCgAW0AAAAwQZokSahBbJlMCGf//p4QAABFVcB5ANViCzFDBUpxRshhV1pnZxyi7aJgyD9kqVnBAAAALUGeQkUVLCP/AAAWvEPPhHSWoAlvATIVgIAE4dNSd/zxpcElW/R8qfD4wy+ltwAAABYBnmF0R/8AAAMACj+0PYM6OImY3BWKAAAAGAGeY2pH/wAAI78EK8E5QzqndnoY7BDvBwAAACVBmmhJqEFsmUwIZ//+nhAAAEVR9fWJODc41kAIEQw8sbEYbWzAAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAEwGepXRH/wAAI7CjEYLCPBG5OwcAAAAOAZ6nakf/AAADAAADAakAAAAwQZqsSahBbJlMCGf//p4QAABFTlgSAOIb1uVQZijvOjXZ5QeqZV9hTtomDCNkGpWdAAAAFUGeykUVLCP/AAAWtT9lBBm8rVAj4QAAABIBnul0R/8AACPDF3VRUNEkwoIAAAAkAZ7rakf/AAAisjCoqoB4dyoAITOHAD0cuj0s2DfWAKwA2WzBAAAANkGa8EmoQWyZTAhn//6eEAAAAwAzoloC+ACo5gQ/B56XptU4iOZhi2N/facdoiCLF4VzLn6SwAAAAB5Bnw5FFSwj/wAAFr6jniCWuV5tL6Z43wj9E311+zEAAAAaAZ8tdEf/AAAjwytSQAiN6KvwkNRUOzn2eOEAAAAZAZ8vakf/AAAjvwQrwyzSgnaeCtgPYvN5JgAAADpBmzRJqEFsmUwIZ//+nhAAAENSc1gAjA3gsTEjd5QhqUwdR7v4GpOA3KEHuoqx8NOOfssfom2nYLc+AAAAG0GfUkUVLCP/AAAWLE7jfa7MQolv3hYezSJbMQAAABsBn3F0R/8AAAMARZA5ttO2jF/BhHpettK0Q7cAAAAlAZ9zakf/AAAivxvavFKOZagAQ+5aI0YrjPEy07eegqwF4e/2YQAAADlBm3hJqEFsmUwIZ//+nhAAAEVOYL2O0AHGM4K8AAU3AaJi56N8xZ9+GKnGUV8yT9Tnsz5Lc7RVkvAAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAAcAZ+1dEf/AAAjwyCY80OU4XeiiAASWdtHCC2eOQAAAA4Bn7dqR/8AAAMAAAMBqQAAADZBm7xJqEFsmUwIZ//+nhAAAEVVDYBXqwAdA3D9bPsfw07aJgx9YXW5FQOoFDa4iXOf76TCX5EAAAAWQZ/aRRUsI/8AABa1QCJShCt+N7lz4AAAABIBn/l0R/8AACPDF3VRUNEkwoIAAAAaAZ/7akf/AAAisjCoqoB4Qcn2Is7JZZzsVg0AAAAeQZvgSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGeHkUVLCP/AAAWtStDIPrT94EfAAAAEgGePXRH/wAAI8MXdVFQ0STCgwAAAA4Bnj9qR/8AAAMAAAMBqQAAACRBmiRJqEFsmUwIZ//+nhAAAEVVDWartomDH6M6AGfLTsMS/IEAAAAUQZ5CRRUsI/8AABa1K0Mg+tP3gR8AAAASAZ5hdEf/AAAjwxd1UVDRJMKCAAAAGQGeY2pH/wAAAwAKOUc45CmKsc3/JaI6KxUAAAAeQZpoSahBbJlMCGf//p4QAABFVQ1mq7aJgx+f8EvyAAAAFEGehkUVLCP/AAAWtStDIPrT94EfAAAAEgGepXRH/wAAI8MXdVFQ0STCgwAAAA4BnqdqR/8AAAMAAAMBqQAAAB5BmqxJqEFsmUwIX//+jLAAAEYUwIZtVQvt6kOu1s0AAAAzQZ7KRRUsI/8AABa8Q8+EdJaRvmAA7QuMf/8ISGrPeE+jQFJngclKn+JH3MbqFgACg/lxAAAAFgGe6XRH/wAAAwAKP5fEzeJmmYhhWKAAAAAYAZ7rakf/AAAjvwQrwTkydwN4m6vA92+DAAAAM0Ga8EmoQWyZTAhf//6MsAAAAwAzzsyAAqNVyOEOThZa719VsDKNZJeM8/4d/VLnJKQaFAAAAB5Bnw5FFSwj/wAAFsCbP8tCMuTkgb29nLMQJvrr9mEAAAASAZ8tdEf/AAAjwxd1UVDRJMKDAAAAGQGfL2pH/wAAI78EK8Ms0oJ2ngrYD2LzeSYAAAA7QZs0SahBbJlMCF///oywAABEWF6IRAEI8mude1B5fVPxdxmn8q7CzAu1yPgtvuSAf3/Yz/AKJAsHx4AAAAAbQZ9SRRUsI/8AABYsTuN9rsxCiW/eFh7NIlsxAAAAGwGfcXRH/wAAAwAaVBbDIaiq2O5qJOCBH4dswAAAACgBn3NqR/8AACK/G9q8VIE8ADaAFP2FFCpAa04dLKVeAK1yBl8hZKxRAAAALkGbeEmoQWyZTAhP//3xAAADAp+YFP3rAESFYGwyzi4lLklfO9tL0Gf12mstfDwAAAAUQZ+WRRUsI/8AABa1K0Mg+tP3gR8AAAAhAZ+1dEf/AAAjwvZ0UkAIkANwhW0OVMlfOX1jo2bbvCghAAAADgGft2pH/wAAAwAAAwGpAAAAFkGbuUmoQWyZTAj//IQAAAMAAAMAwIEAAAFKZYiEACv//vZzfAprRzOVLgV292aj5dCS5fsQYPrQAAADAAADAABNxUTOiwpjxNkAAAMAXEAR4LAI8JULYSEfY6QycCY2IAiULAF6jxnFgq+cRH2IVNNQM4wV9euSe8VXrQS4F4AmUwiFLEyyAk/XH6xE+aQi8LwoBcYIwU7cQHyUhEPOeFUOKy4MolpVcAWQAwPIQXva0LK39P6UTpXxdm/wVawJ7adDhvLXAp1IusqLfOoOM4vDdStvhTVJlwvAARHWh+jGpNHdbXBWi0nqv9PQFGp7yV400k/N/im0U4AQeIIy4jbIUteW+v2jk/CEiBNiyT2e38fMXCwDWUx2+lniI7EMDQecbVQ+fYRdONViNAAMUixILv8BEon9SLNC2xoaQDMZko47oxDoV4YwSI48uftLdq8vuDRyfvZOuqAAAAMAAAMAANWAAAAx221vb3YAAABsbXZoZAAAAAAAAAAAAAAAAAAAA+gAAE40AAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAADEFdHJhawAAAFx0a2hkAAAAAwAAAAAAAAAAAAAAAQAAAAAAAE40AAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAJYAAABkAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAABONAAAAgAAAQAAAAAwfW1kaWEAAAAgbWRoZAAAAAAAAAAAAAAAAAAAMgAAA+kAVcQAAAAAAC1oZGxyAAAAAAAAAAB2aWRlAAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAAMChtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAC/oc3RibAAAAJxzdHNkAAAAAAAAAAEAAACMYXZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAJYAZAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAADZhdmNDAWQAH//hABlnZAAfrNlAmDPl4QAAAwABAAADAGQPGDGWAQAGaOvjyyLA/fj4AAAAABhzdHRzAAAAAAAAAAEAAAPpAAABAAAAACRzdHNzAAAAAAAAAAUAAAABAAAA+wAAAfUAAALvAAAD6QAAHyBjdHRzAAAAAAAAA+IAAAABAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAACAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAACAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAACAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAACAAACAAAAABxzdHNjAAAAAAAAAAEAAAABAAAD6QAAAAEAAA+4c3RzegAAAAAAAAAAAAAD6QAABNQAAAC3AAAARwAAAEAAAAA+AAAAxQAAAEcAAAA/AAAANQAAAFIAAABAAAAAJgAAADMAAAB1AAAALgAAACEAAABIAAAALwAAACEAAAAgAAAAewAAADMAAAAmAAAALQAAAHYAAABEAAAAKwAAACAAAABZAAAAJQAAACkAAAA0AAAASwAAAEYAAAAnAAAAKgAAAKEAAAAvAAAArAAAADsAAAAwAAAAOAAAAEcAAABNAAAAOQAAAFYAAAA2AAAAIQAAABsAAACAAAAANwAAACIAAAAvAAAAUgAAADEAAAAbAAAAKQAAAFIAAAA5AAAAJgAAAGsAAAAwAAAALAAAADkAAAA6AAAAOQAAACkAAAAjAAAAeQAAAC4AAAAkAAAAJQAAAGwAAAAwAAAAJwAAACAAAABIAAAAOgAAACQAAAAcAAAAJQAAACYAAAAcAAAAIQAAACIAAAA/AAAAKAAAACEAAAAfAAAAMgAAAB0AAAAkAAAAGQAAADMAAAA0AAAAHgAAADAAAABUAAAAKQAAAEAAAAAZAAAAXgAAAB4AAAAWAAAAHAAAADUAAAAsAAAAIwAAABoAAAAxAAAAPAAAAC8AAAAhAAAAQQAAADUAAAAvAAAAJAAAADIAAAAwAAAAGQAAACMAAABGAAAAHQAAACEAAAAgAAAAMgAAACwAAAAYAAAAGwAAAC0AAAAYAAAALgAAACAAAAAiAAAAMAAAAB4AAAAfAAAAKAAAABgAAAAtAAAAFwAAACIAAAAhAAAAFAAAABcAAAAiAAAAGAAAACEAAAAXAAAAIgAAACIAAAAcAAAAIgAAACIAAAAYAAAALQAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAgAAAAFwAAACIAAAAZAAAAEgAAABcAAAAiAAAAGAAAACAAAAAXAAAALAAAADIAAAAcAAAAIgAAACcAAAAYAAAALAAAABcAAAAiAAAALwAAABwAAAArAAAAIgAAABgAAAAuAAAAFwAAACwAAAAZAAAAEgAAABcAAAAiAAAAGAAAAB8AAAAXAAAAIwAAABkAAAASAAAAFwAAACIAAAAYAAAANQAAABcAAAAiAAAAMQAAABwAAAArAAAAIgAAABgAAAAnAAAAIAAAACIAAAAwAAAAHAAAACsAAAAiAAAAGAAAACAAAAAgAAAAIgAAABkAAAASAAAAFwAAACIAAAAYAAAAFgAAACAAAAAiAAAAKQAAABsAAAAeAAAAIgAAABgAAAAWAAAAIAAAACIAAAAgAAAAGwAAAB4AAAAiAAAAGAAAABYAAAASAAAAIgAAACAAAAAbAAAAHgAAABoAAAGgAAAAdAAAAB8AAAAVAAAAHAAAADEAAAApAAAAIAAAABcAAAA3AAAAHgAAABIAAAAcAAAAKQAAACoAAAAgAAAAGAAAAC8AAAA2AAAAHgAAACUAAAAsAAAAMAAAACAAAAAYAAAAQQAAAB4AAAASAAAAHAAAACgAAAAgAAAALQAAABgAAABKAAAAHgAAABIAAAAcAAAALgAAACgAAAAhAAAAFwAAAEEAAAAfAAAAEgAAABwAAAAoAAAAIAAAAC0AAAAXAAAANwAAABcAAAAgAAAAFQAAAB8AAAAuAAAAFwAAABgAAABcAAAAHwAAAB8AAAAcAAAAKQAAACEAAAAqAAAAFwAAADsAAAAZAAAAEgAAABcAAAAiAAAAJAAAACAAAAAXAAAAKQAAABkAAAASAAAAFwAAACIAAAAjAAAAIAAAABcAAAAiAAAAMAAAAB4AAAAhAAAAIwAAABsAAAAeAAAAFwAAADAAAAAZAAAAEgAAABcAAAAiAAAAIgAAAB4AAAAXAAAAMAAAACIAAAAcAAAAIQAAACIAAAAhAAAAKgAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAACEAAAAfAAAAFwAAACIAAAAZAAAAEgAAABcAAAAiAAAAIQAAAB8AAAAXAAAALAAAABkAAAASAAAAFwAAACIAAAAiAAAAKQAAABcAAAAsAAAAIwAAABwAAAArAAAAIgAAABgAAAAvAAAAFwAAACIAAAAZAAAAEgAAABcAAAAiAAAAGAAAACgAAAAXAAAAIgAAAC8AAAAcAAAAKwAAACIAAAAYAAAALwAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAACIAAAAtAAAAFwAAACIAAAAZAAAAEgAAABcAAAAiAAAAGAAAACgAAAAXAAAAIgAAACkAAAAbAAAAHgAAACIAAAAYAAAAGgAAABcAAAAuAAAAGQAAABIAAAAXAAAAIgAAABgAAAAfAAAAGgAAAC0AAAAhAAAAGwAAAB8AAAAiAAAAGAAAABgAAAAYAAAAIgAAACAAAAAbAAAAHgAAACIAAAAYAAAAFgAAABIAAAAiAAAALAAAABsAAAAqAAAAIgAAABgAAAAWAAAAEgAAACIAAAAsAAAAGwAAACsAAAAiAAAAGAAAABYAAAASAAAAIgAAACEAAAAbAAAAKgAAACIAAAAYAAAAFgAAABIAAAAiAAAAKgAAABsAAAAqAAAAIgAAABgAAAAWAAAAEgAAACIAAAAxAAAAGwAAAB8AAAAiAAAAGAAAABYAAAASAAAAIgAAAC8AAAAbAAAAJwAAACIAAAAYAAAAFgAAABIAAAAaAAAB3gAAAJYAAAAoAAAANwAAABsAAABMAAAAIAAAABYAAAAcAAAAKQAAACwAAAAsAAAAGAAAADwAAAAZAAAAEgAAABcAAAAoAAAAJQAAAC0AAAAXAAAANgAAABkAAAASAAAAFwAAACIAAAAoAAAAHwAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAAB0AAAAfAAAAFwAAAC0AAAAZAAAAEgAAABcAAAAiAAAAJwAAAB8AAAAXAAAAKgAAABkAAAASAAAAFwAAACIAAAAiAAAAKAAAABcAAAAtAAAAIgAAABwAAAAhAAAAIgAAABgAAAArAAAAFwAAACIAAAAiAAAAHAAAACEAAAAiAAAAGAAAACkAAAAXAAAAIgAAABkAAAASAAAAFwAAACIAAAAYAAAAHwAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAsAAAAFwAAACIAAAAyAAAAHAAAACIAAAAiAAAAGAAAAC8AAAAZAAAAIgAAADMAAAAcAAAAIAAAACIAAAAYAAAALQAAABkAAAAiAAAAKgAAABwAAAAsAAAAIgAAABgAAAAtAAAAGQAAACIAAAAZAAAAEgAAABcAAAAiAAAAGAAAACcAAAAZAAAANwAAADIAAAAcAAAALAAAACIAAAAYAAAAFwAAABoAAAAyAAAALgAAABwAAAAtAAAAIgAAABgAAAAWAAAAEgAAACIAAAAwAAAAHAAAACsAAAAiAAAAGAAAABYAAAASAAAAIgAAACMAAAAbAAAALQAAACIAAAAYAAAAFgAAABIAAAAiAAAAIwAAABsAAAArAAAAKQAAABgAAAAWAAAAEgAAADwAAAAtAAAAGwAAACwAAAA/AAAAIwAAABgAAAAeAAAAKwAAACwAAAAcAAAAHwAAADoAAAAYAAAAJQAAABIAAAA9AAAAIwAAABsAAAArAAAALAAAABgAAAAWAAAAEgAAACIAAAAZAAAAEgAAABcAAABCAAAAIwAAABYAAAAeAAAAKwAAADMAAAAcAAAAHwAAAEEAAAAYAAAAFgAAABIAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAWAAAAEgAAACIAAAA0AAAAGwAAADMAAAAiAAAAGAAAABYAAAASAAAANQAAAC4AAAAWAAAAMAAAAEQAAAAjAAAAGAAAAB4AAAAsAAAAJQAAACEAAAAuAAAAQgAAABgAAAAhAAAAEgAAACIAAAAkAAAAFgAAAC4AAABKAAAAIwAAABgAAAAeAAAAMQAAACQAAAAfAAAAHQAAABsAAAAUAAAAKAAAABIAAAA/AAAAJQAAABYAAAAfAAAAHQAAAZkAAABxAAAAGwAAABcAAAAXAAAAIgAAACIAAAAqAAAAHwAAADIAAAAzAAAAHAAAACAAAAAiAAAAGAAAACsAAAAXAAAALAAAABkAAAASAAAAFwAAACIAAAAiAAAAHwAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAqAAAAFwAAAC0AAAAjAAAAHAAAAC0AAAAiAAAAGAAAAC0AAAAXAAAAIgAAABkAAAASAAAAFwAAACIAAAAYAAAALQAAABcAAAAiAAAALwAAABwAAAAsAAAAIgAAABgAAAAxAAAAFwAAACIAAAAZAAAAEgAAABcAAAAiAAAAGAAAAC0AAAAXAAAAIgAAAC8AAAAcAAAAHgAAACIAAAAYAAAAKAAAABcAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAZAAAAFwAAACIAAAAgAAAAGwAAACoAAAAiAAAAGAAAABYAAAAXAAAALAAAABkAAAASAAAAFwAAACIAAAAYAAAAFgAAABkAAAArAAAAKgAAABsAAAAqAAAAIgAAABgAAAAWAAAAGAAAACIAAAArAAAAGwAAACsAAAAiAAAAGAAAABgAAAAYAAAAIgAAACwAAAAbAAAALAAAACIAAAAYAAAAGAAAABgAAAAiAAAAGQAAABIAAAAXAAAAIgAAABgAAAAWAAAAGAAAACIAAAArAAAAGwAAAB8AAAAiAAAAGAAAABYAAAASAAAANgAAAC8AAAAbAAAAKwAAAEcAAAAjAAAAGAAAAB4AAAA3AAAALgAAABsAAAAsAAAAPgAAABgAAAAlAAAAEgAAAD8AAAAzAAAAGwAAACAAAAAiAAAAGAAAABYAAAASAAAAIgAAAC8AAAAbAAAALAAAACgAAAAYAAAAFgAAABIAAAAiAAAAKAAAABUAAAAXAAAAKwAAACIAAAAWAAAAHQAAACkAAAAmAAAAHwAAABsAAABEAAAAGAAAABYAAAASAAAAIgAAABgAAAAWAAAAJAAAACIAAAAYAAAAFgAAABIAAAA0AAAAMQAAABoAAAAcAAAAKQAAABgAAAAXAAAAEgAAADQAAAAZAAAAFgAAACgAAAA6AAAAIgAAAB4AAAAdAAAAPgAAAB8AAAAfAAAAKQAAAD0AAAAYAAAAIAAAABIAAAA6AAAAGgAAABYAAAAeAAAAIgAAABgAAAAWAAAAEgAAACgAAAAYAAAAFgAAAB0AAAAiAAAAGAAAABYAAAASAAAAIgAAADcAAAAaAAAAHAAAADcAAAAiAAAAFgAAAB0AAAA/AAAAHwAAAB8AAAAsAAAAMgAAABgAAAAlAAAAEgAAABoAAAFOAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAAAFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjUxLjEwMQ==\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/6_3/'\n",
    "env = make_env(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO\n",
    "\n",
    "# Try to run this on another environment of your choice from OpenAI Gym\n",
    "# read the accompanying text and try to enahnce the network using various variants\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with **prioritized** experience replay and target networks. We can see that using prioritized buffer speeds up the training significantly with higher scores. This is even more evident with more complex environments like Atari games. \n",
    "\n",
    "\n",
    "We can further improve this agent with additional tricks. As we go along, we will be implementing many of these variants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
